dobo 2.0.0 → 2.2.0

package/lib/sanitize-schema.js

@@ -1,197 +0,0 @@
-import genericPropSanitizer from './generic-prop-sanitizer.js'
-
-async function sanitizeFeature (item) {
-  const { get, isPlainObject, mergeWith, isArray } = this.lib._
-  for (const f of item.feature) {
-    const feature = get(this.feature, f.name) // source from collectFeature
-    if (!feature) this.fatal('unknownFeature%s%s', f.name, item.name)
-    let [ns, path] = f.name.split('.')
-    if (!path) ns = this.name
-    const input = await feature.call(this.app[ns], f)
-    let props = input.properties
-    if (isPlainObject(props)) props = [props]
-    if (props.length > 0) item.properties.push(...props)
-    item.globalRules = item.globalRules ?? []
-    if (input.globalRules) {
-      item.globalRules = mergeWith(item.globalRules, input.globalRules, (oval, sval) => {
-        if (isArray(oval)) return oval.concat(sval)
-      })
-    }
-  }
-}
-
-async function sanitizeIndexes (item) {
-  const { generateId } = this.app.bajo
-  for (const idx of item.indexes) {
-    if (!idx.name) idx.name = `${(item.modelName ?? item.name).toUpperCase()}_${generateId()}`
-    if (!(typeof idx.fields === 'string' || Array.isArray(idx.fields))) this.fatal('onlyAcceptFields%s%s', 'indexes', item.name)
-  }
-}
-
-async function sanitizeFullText (item) {
-  for (const f of item.fullText.fields ?? []) {
-    const prop = item.properties.find(p => p.name === f)
-    if (!prop) this.fatal('invalidFieldName%s%s', f, item.name)
-    // if (prop.type !== 'text') fatal.call(this, 'Fulltext index only available for field type \'text\' in \'%s@%s\'', f, item.name)
-  }
-}
-
-async function sanitizeSchema (items) {
-  const { defaultsDeep } = this.lib.aneka
-  const { freeze, fatal, importModule, join, breakNsPath, runHook } = this.app.bajo
-  const { isEmpty, orderBy, map, keys, findIndex, find, each, isString, get, isPlainObject, camelCase, uniq, filter } = this.lib._
-  const propTypes = keys(this.propType)
-  const schemas = []
-  this.log.debug('loadingDbSchemas')
-  for (const k in items) {
-    this.log.trace('- %s (%d)', k, keys(items[k]).length)
-    for (const f in items[k]) {
-      const item = items[k][f]
-      item.cacheable = item.cacheable ?? true
-      await runHook(`dobo.${camelCase(item.name)}:beforeSanitizeSchema`, item)
-      const conn = find(this.connections, { name: item.connection })
-      if (!conn) fatal.call(this, 'Unknown connection \'%s@%s\'', item.name, item.connection)
-      item.fullText = item.fullText ?? { fields: [] }
-      item.indexes = item.indexes ?? []
-      let { ns, path: type } = breakNsPath(conn.type)
-      if (isEmpty(type)) type = conn.type
-      const driver = find(this.drivers, { type, ns, driver: conn.driver })
-      if (driver.lowerCaseModel) item.name = item.name.toLowerCase()
-      let file = `${ns}:/extend/${this.name}/lib/${type}/prop-sanitizer.js`
-      let propSanitizer = await importModule(file)
-      if (!propSanitizer) propSanitizer = genericPropSanitizer
-      for (const idx in item.properties) {
-        let prop = item.properties[idx]
-        if (isString(prop)) {
-          let [name, type, maxLength, index, required] = prop.split(':')
-          if (!type) type = 'string'
-          maxLength = maxLength ?? 255
-          prop = { name, type }
-          if (type === 'string') prop.maxLength = parseInt(maxLength) || undefined
-          if (!isEmpty(index)) prop.index = { type: index === 'true' ? 'default' : index }
-          prop.required = required === 'true'
-          item.properties[idx] = prop
-        } else {
-          if (isString(prop.index)) prop.index = { type: prop.index }
-          else if (prop.index === true) prop.index = { type: 'default' }
-        }
-      }
-      const idx = findIndex(item.properties, { name: 'id' })
-      if (idx === -1) item.properties.unshift(driver.idField)
-      item.feature = item.feature ?? []
-      await sanitizeFeature.call(this, item)
-      item.disabled = item.disabled ?? []
-      if (item.disabled === 'all') item.disabled = ['find', 'get', 'create', 'update', 'remove']
-      else if (item.disabled === 'readonly') item.disabled = ['create', 'update', 'remove']
-      for (const idx in item.properties) {
-        let prop = item.properties[idx]
-        if (!prop.type) {
-          prop.type = 'string'
-          prop.maxLength = 255
-        }
-        if (!propTypes.includes(prop.type)) {
-          let success = false
-          const feature = get(this.feature, isPlainObject(prop.type) ? prop.type.name : prop.type)
-          if (feature) {
-            let opts = { fieldName: prop.name }
-            if (isPlainObject(prop.type)) opts = defaultsDeep(opts, prop.type)
-            else opts.name = prop.type
-            const feat = find(item.feature, opts)
-            if (!feat) item.feature.push(opts)
-            const input = await feature.call(this, opts)
-            if (input.properties && input.properties.length > 0) {
-              prop = input.properties[0]
-              success = true
-            }
-          }
-          if (!success) fatal.call(this, 'Unsupported property type \'%s@%s\' in \'%s\'', prop.type, prop.name, item.name)
-        }
-        if (prop.index) {
-          if (prop.index === 'unique') prop.index = { type: 'unique' }
-          else if (prop.index === 'fulltext') prop.index = { type: 'fulltext' }
-          else if (prop.index === 'primary') prop.index = { type: 'primary' }
-          else if (prop.index === true) prop.index = { type: 'default' }
-        }
-
-        await propSanitizer.call(this, { prop, schema: item, connection: conn, driver })
-        if (prop.index && prop.index.type === 'primary' && prop.name !== 'id') fatal.call(this, 'Primary index should only be used for \'id\' field')
-        if (prop.index && prop.index.type === 'fulltext') {
-          item.fullText.fields.push(prop.name)
-          prop.index.type = 'default'
-        }
-        item.properties[idx] = prop
-      }
-      await sanitizeIndexes.call(this, item)
-      await sanitizeFullText.call(this, item)
-      const all = []
-      each(item.properties, p => {
-        if (!all.includes(p.name)) all.push(p.name)
-        else fatal.call(this, 'Field \'%s@%s\' should be used only once', p.name, item.name)
-      })
-      file = `${ns}:/extend/${this.name}/lib/${type}/schema-sanitizer.js`
-      const schemaSanitizer = await importModule(file)
-      if (schemaSanitizer) await schemaSanitizer.call(this, { schema: item, connection: conn, driver })
-      schemas.push(item)
-    }
-  }
-  for (const i in schemas) {
-    const schema = schemas[i]
-    const sortables = []
-    const hidden = []
-    for (const i2 in schema.properties) {
-      const prop = schema.properties[i2]
-      if (prop.type !== 'string') delete prop.maxLength
-      if (prop.rel) {
-        for (const key in prop.rel) {
-          let def = prop.rel[key]
-          if (isString(def)) {
-            const [rschema, rfield] = def.split(':')
-            def = { schema: rschema, propName: rfield }
-          }
-          def.type = def.type ?? 'one-to-one'
-          const rel = find(schemas, { name: def.schema })
-          if (!rel) {
-            fatal.call(this, 'No schema found for relationship \'%s@%s:%s\'', `${def.schema}:${def.propName}`, schema.name, prop.name)
-          }
-          const rprop = find(rel.properties, { name: def.propName })
-          if (!rprop) fatal.call(this, 'No property found for relationship \'%s@%s:%s\'', `${def.schema}:${def.propName}`, schema.name, prop.name)
-          def.fields = def.fields ?? '*'
-          if (['*', 'all'].includes(def.fields)) {
-            const relschema = find(schemas, { name: def.schema })
-            def.fields = relschema.properties.map(p => p.name)
-          }
-          if (def.fields.length > 0 && !def.fields.includes('id')) def.fields.push('id')
-          for (const f of def.fields) {
-            const p = find(rel.properties, { name: f })
-            if (!p) fatal.call(this, 'Unknown property for field \'%s\' in relationship \'%s@%s:%s\'', p, `${def.schema}:${def.propName}`, schema.name, prop.name)
-          }
-          prop.type = rprop.type
-          if (rprop.type === 'string') prop.maxLength = rprop.maxLength
-          else {
-            delete prop.maxLength
-            delete prop.minLength
-          }
-          prop.rel[key] = def
-        }
-        // TODO: propSanitizer must be called again
-      }
-      if (prop.hidden) hidden.push(prop.name)
-      if (prop.index) sortables.push(prop.name)
-      delete prop.hidden
-      schema.properties[i2] = prop
-    }
-    // sortables
-    each(schema.indexes, item => {
-      sortables.push(...item.fields)
-    })
-    // hidden
-    schema.hidden = uniq(filter((schema.hidden ?? []).concat(hidden), item => map(schema.properties, 'name').includes(item)))
-    schema.sortables = sortables
-    await runHook(`dobo.${camelCase(schema.name)}:afterSanitizeSchema`, schema)
-  }
-  this.schemas = orderBy(schemas, ['buildLevel', 'name'])
-  freeze(this.schemas)
-  this.log.debug('loadedSchemas%s', join(map(this.schemas, 'name')))
-}
-
-export default sanitizeSchema

package/lib/single-rel-rows.js

@@ -1,38 +0,0 @@
-async function singleRelRows ({ schema, record, options = {} }) {
-  const { isSet } = this.lib.aneka
-  const { find } = this.lib._
-  const props = schema.properties.filter(p => isSet(p.rel) && !(options.hidden ?? []).includes(p.name))
-  const rels = {}
-  options.rels = options.rels ?? []
-  if (props.length > 0) {
-    for (const prop of props) {
-      for (const key in prop.rel) {
-        if (!((typeof options.rels === 'string' && ['*', 'all'].includes(options.rels)) || options.rels.includes(key))) continue
-        const val = prop.rel[key]
-        if (val.fields.length === 0) continue
-        const relschema = this.getSchema(val.schema)
-        const relFilter = options.filter ?? {}
-        const query = {}
-        query[val.propName] = record[prop.name]
-        if (val.propName === 'id') {
-          const idField = find(relschema.properties, { name: 'id' })
-          if (idField.type === 'integer') query[val.propName] = parseInt(query[val.propName])
-        }
-
-        relFilter.query = query
-        const relOptions = { dataOnly: true, rels: [] }
-        const results = await this.recordFind(relschema.name, relFilter, relOptions)
-        const fields = [...val.fields]
-        if (!fields.includes(prop.name)) fields.push(prop.name)
-        const data = []
-        for (const res of results) {
-          data.push(await this.pickRecord({ record: res, fields, schema: relschema }))
-        }
-        rels[key] = ['one-to-one'].includes(val.type) ? data[0] : data
-      }
-    }
-  }
-  record._rel = rels
-}
-
-export default singleRelRows

package/method/attachment/copy-uploaded.js

@@ -1,34 +0,0 @@
-import path from 'path'
-
-async function copyUploaded (name, id, options = {}) {
-  const { fs } = this.lib
-  const { req, setField, setFile, mimeType, stats, silent = true } = options
-  name = this.attachmentPreCheck(name)
-  if (!name) {
-    if (silent) return
-    throw this.error('isMissing%s', this.print.write('field.name'))
-  }
-  if (!this.app.waibu) {
-    if (silent) return
-    throw this.error('missingPlugin%s', 'Waibu')
-  }
-  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 [field, ...parts] = path.basename(f).split('@')
-    if (parts.length === 0) continue
-    field = setField ?? field
-    const file = setFile ?? parts.join('@')
-    const opts = { source: f, field, file, mimeType, stats, req, silent: true }
-    const rec = await this.attachmentCreate(name, id, opts)
-    if (!rec) continue
-    delete rec.dir
-    result.push(rec)
-    if (setField || setFile) break
-  }
-  fs.removeSync(dir)
-  return result
-}
-
-export default copyUploaded

package/method/attachment/create.js

@@ -1,29 +0,0 @@
-import mergeAttachmentInfo from '../../lib/merge-attachment-info.js'
-
-async function create (name, id, options = {}) {
-  const { fs } = this.lib
-  const { isEmpty } = this.lib._
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  const { source, field = 'file', file } = options
-  if (isEmpty(file)) return
-  if (!source) throw this.error('isMissing%s', this.print.write('field.source'))
-  const baseDir = await this.attachmentGetPath(name, id, field, file, { dirOnly: true })
-  const { fullPath, stats, mimeType, req } = options
-
-  let dir = `${baseDir}/${field}`
-  if ((field || '').endsWith('[]')) dir = `${baseDir}/${field.replace('[]', '')}`
-  const dest = `${dir}/${file}`.replaceAll('//', '/')
-  await fs.ensureDir(dir)
-  await fs.copy(source, dest)
-  const rec = {
-    field: field === '' ? undefined : field,
-    dir,
-    file
-  }
-  await mergeAttachmentInfo.call(this, rec, dest, { mimeType, fullPath, stats })
-  if (!options.silent && req && req.flash) req.flash('notify', req.t('attachmentUploaded'))
-  return rec
-}
-
-export default create

package/method/attachment/find.js

@@ -1,27 +0,0 @@
-import mergeAttachmentInfo from '../../lib/merge-attachment-info.js'
-
-async function find (name, id, options = {}) {
-  const { fastGlob, fs } = this.lib
-  const { getPluginDataDir } = this.app.bajo
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  const dir = `${getPluginDataDir(this.name)}/attachment/${name}/${id}`
-  if (!fs.existsSync(dir)) return []
-  const files = await fastGlob(`${dir}/**/*`)
-  const { fullPath, stats, mimeType } = options
-  const recs = []
-  for (const f of files) {
-    const item = f.replace(dir, '')
-    let [, field, file] = item.split('/')
-    if (!file) {
-      file = field
-      field = null
-    }
-    const rec = { field, file }
-    await mergeAttachmentInfo.call(this, rec, f, { mimeType, fullPath, stats })
-    recs.push(rec)
-  }
-  return recs
-}
-
-export default find

package/method/attachment/get-path.js

@@ -1,12 +0,0 @@
-async function getPath (name, id, field, file, options = {}) {
-  const { getPluginDataDir } = this.app.bajo
-  const { pascalCase } = this.lib.aneka
-  const { fs } = this.lib
-  const dir = `${getPluginDataDir(this.name)}/attachment/${pascalCase(name)}/${id}`
-  if (options.dirOnly) return dir
-  const path = field ? `${dir}/${field}/${file}` : `${dir}/${file}`
-  if (!fs.existsSync(path)) throw this.error('notFound')
-  return path
-}
-
-export default getPath

package/method/attachment/get.js

@@ -1,12 +0,0 @@
-async function get (name, id, field, file, options = {}) {
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  const { find } = this.lib._
-  const all = await this.attachmentFind(name, id, options)
-  if (field === 'null') field = null
-  const data = find(all, { field, file })
-  if (!data) throw this.error('notFound', { statusCode: 404 })
-  return data
-}
-
-export default get

package/method/attachment/pre-check.js

@@ -1,9 +0,0 @@
-function preCheck (name) {
-  const { pascalCase } = this.lib.aneka
-  name = pascalCase(name)
-  const schema = this.getSchema(name)
-  if (!schema.attachment) return false
-  return name
-}
-
-export default preCheck

package/method/attachment/remove.js

@@ -1,11 +0,0 @@
-async function remove (name, id, field, file, options = {}) {
-  const { fs } = this.lib
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  const path = await this.attachmentGetPath(name, id, field, file)
-  const { req } = options
-  await fs.remove(path)
-  if (req && req.flash) req.flash('notify', req.t('attachmentRemoved'))
-}
-
-export default remove

package/method/attachment/update.js

@@ -1,7 +0,0 @@
-import create from './create.js'
-
-async function update (name, id, options = {}) {
-  return create.call(this, name, id, options)
-}
-
-export default update

package/method/bulk/create.js

@@ -1,46 +0,0 @@
-import buildBulkAction from '../../lib/build-bulk-action.js'
-import execValidation from '../../lib/exec-validation.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-async function create (name, inputs, options) {
-  const { isSet } = this.lib.aneka
-  const { generateId, runHook } = this.app.bajo
-  const { clearModel } = this.cache ?? {}
-  const { find } = this.lib._
-  options.dataOnly = options.dataOnly ?? true
-  options.truncateString = options.truncateString ?? true
-  const { noHook, noValidation } = options
-  await this.modelExists(name, true)
-  const { handler, schema } = await buildBulkAction.call(this, name, 'create', options)
-  const idField = find(schema.properties, { name: 'id' })
-  const bodies = [...inputs]
-  for (let b of bodies) {
-    b.id = b.id ?? generateId(idField.type === 'integer' ? 'int' : undefined)
-    b = await this.sanitizeBody({ body: b, schema, strict: true })
-    if (!noValidation) b = await execValidation.call(this, { noHook, name, b, options })
-  }
-  if (!noHook) {
-    await runHook(`${this.name}:beforeBulkCreate`, name, bodies, options)
-    await runHook(`${this.name}.${name}:beforeBulkCreate`, bodies, options)
-  }
-  for (const idx in bodies) {
-    await execFeatureHook.call(this, 'beforeCreate', { schema, body: bodies[idx] })
-    // TODO: check unique?
-    for (const k in bodies[idx]) {
-      if (bodies[idx][k] === undefined) continue
-      const prop = find(schema.properties, { name: k })
-      if (options.truncateString && isSet(bodies[idx][k]) && prop && ['string', 'text'].includes(prop.type)) bodies[idx][k] = bodies[idx][k].slice(0, prop.maxLength)
-    }
-  }
-  await handler.call(this, { schema, bodies, options })
-  for (const idx in bodies) {
-    await execFeatureHook.call(this, 'afterCreate', { schema, body: bodies[idx] })
-  }
-  if (!noHook) {
-    await runHook(`${this.name}.${name}:afterBulkCreate`, bodies, options)
-    await runHook(`${this.name}:afterBulkCreate`, name, bodies, options)
-  }
-  if (clearModel) await clearModel({ model: name })
-}
-
-export default create

package/method/model/clear.js

@@ -1,22 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-async function clear (name, options = {}) {
-  const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
-
-  await this.modelExists(name, true)
-  const { noHook } = options
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-clear', options)
-  if (!noHook) {
-    await runHook(`${this.name}:beforeModelClear`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelClear`, options)
-  }
-  const resp = await handler.call(this.app[driver.ns], { schema, options })
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelClear`, options, resp)
-    await runHook(`${this.name}:afterModelClear`, schema, options, resp)
-  }
-  return resp
-}
-
-export default clear

package/method/model/create.js

@@ -1,19 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-async function create (name, options = {}) {
-  const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
-
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-create', options)
-  if (!options.noHook) {
-    await runHook(`${this.name}:beforeModelCreate`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelCreate`, options)
-  }
-  await handler.call(this.app[driver.ns], { schema, options })
-  if (!options.noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelCreate`, options)
-    await runHook(`${this.name}:afterModelCreate`, schema, options)
-  }
-}
-
-export default create

package/method/model/drop.js

@@ -1,19 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-async function drop (name, options = {}) {
-  const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-drop', options)
-
-  if (!options.noHook) {
-    await runHook(`${this.name}:beforeModelDrop`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelDrop`, options)
-  }
-  await handler.call(this.app[driver.ns], { schema, options })
-  if (!options.noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelDrop`, options)
-    await runHook(`${this.name}:afterModelDrop`, schema, options)
-  }
-}
-
-export default drop

package/method/model/exists.js

@@ -1,24 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-const cache = {}
-
-async function exists (name, thrown, options = {}) {
-  if (cache[name]) return cache[name]
-  const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-exists', options)
-  if (!options.noHook) {
-    await runHook(`${this.name}:beforeModelExists`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelExists`, options)
-  }
-  const exist = await handler.call(this.app[driver.ns], { schema, options })
-  if (!options.noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelExists`, exist, options)
-    await runHook(`${this.name}:afterModelExists`, schema, exist, options)
-  }
-  if (!exist && thrown) throw this.error('modelNotExists%s', name)
-  cache[name] = exist
-  return exist
-}
-
-export default exists

package/method/record/clear.js

@@ -1,24 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-async function clear (name, opts = {}) {
-  const { runHook } = this.app.bajo
-  await this.modelExists(name, true)
-  const { cloneDeep, camelCase, omit } = this.lib._
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  const { noHook } = options
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-clear', options)
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordClear`, name, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordClear`, options)
-  }
-  const resp = await handler.call(this.app[driver.ns], { schema, options })
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordClear`, options, resp)
-    await runHook(`${this.name}:afterRecordClear`, name, options, resp)
-  }
-  return resp
-}
-
-export default clear

package/method/record/count.js

@@ -1,44 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-async function count (name, filter = {}, opts = {}) {
-  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 { dataOnly, noHook, noCache, noFeatureHook } = options
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-count', 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}:beforeRecordCount`, name, filter, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordCount`, filter, options)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeCount', { 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
-    }
-  }
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
-  delete options.record
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordCount`, filter, options, record)
-    await runHook(`${this.name}:afterRecordCount`, name, filter, options, record)
-  }
-  if (set && !noCache) await set({ model: name, filter, options, record })
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterCount', { schema, filter, options, record })
-  return dataOnly ? record.data : record
-}
-
-export default count

package/method/record/create.js

@@ -1,71 +0,0 @@
-import crypto from 'crypto'
-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 create (name, input, opts = {}) {
-  const { generateId, runHook } = this.app.bajo
-  const { isSet } = this.lib.aneka
-  const { clearModel } = this.cache ?? {}
-  const { find, forOwn, cloneDeep, camelCase, omit, get, 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
-  input = cloneDeep(input)
-  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, hidden, forceNoHidden } = options
-  options.truncateString = options.truncateString ?? true
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-create', options)
-  const idField = find(schema.properties, { name: 'id' })
-  const extFields = get(options, 'validation.extFields', [])
-  let body = noSanitize ? cloneDeep(input) : await this.sanitizeBody({ body: input, schema, extFields, strict: true })
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordCreate`, name, body, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordCreate`, body, options)
-  }
-  if (!isSet(body.id)) {
-    if (idField.type === 'string') {
-      if (!options.checksumId) body.id = generateId()
-      else {
-        if (options.checksumId === true) options.checksumId = Object.keys(body)
-        const checksum = pick(body, options.checksumId)
-        body.id = crypto.createHash('md5').update(JSON.stringify(checksum)).digest('hex')
-      }
-    } else if (['integer', 'smallint'].includes(idField.type) && !idField.autoInc) input.id = generateId('int')
-  }
-  if (!noValidation) body = await execValidation.call(this, { name, body, options })
-  if (isSet(body.id) && !noCheckUnique) await checkUnique.call(this, { schema, body })
-  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
-  })
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeCreate', { schema, body: nbody, options })
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, 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.id, body, options, action: 'create' })
-    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordCreated'))
-  }
-  if (clearModel) await clearModel({ model: name, body: nbody, options, record })
-  if (noResult) return
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordCreate`, nbody, options, record)
-    await runHook(`${this.name}:afterRecordCreate`, name, nbody, options, record)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterCreate', { schema, body: nbody, options, record })
-  return dataOnly ? record.data : record
-}
-
-export default create