dobo 1.0.0 → 1.0.1

package/README.md

@@ -1 +1,23 @@
-# dobo
+# dobo
+
+Plugin name: **bajoDb**, alias: **db**
+
+![GitHub package.json version](https://img.shields.io/github/package-json/v/ardhi/dobo) ![NPM Version](https://img.shields.io/npm/v/dobo)
+
+> <br />**Attention**: I do NOT accept any pull request at the moment, thanks!<br /><br />
+
+Database connectivity, tools, ORM/ODM support for [Bajo](https://github.com/ardhi/bajo)
+
+## Installation
+
+Goto your ```<bajo-base-dir>``` and type:
+
+```bash
+$ npm install dobo
+```
+
+Now open your ```<bajo-data-dir>/config/.plugins``` and put ```dobo``` in it
+
+## License
+
+[MIT](LICENSE)

package/bajo/config.json

@@ -0,0 +1,27 @@
+{
+  "alias": "db",
+  "connections": [],
+  "dependencies": [],
+  "mergeProps": ["connections"],
+  "defaults": {
+    "property": {
+      "text": {
+        "kind": "text"
+      },
+      "string": {
+        "length": 50
+      }
+    },
+    "filter": {
+      "limit": 25,
+      "maxLimit": 200,
+      "sort": ["dt:-1", "updatedAt:-1", "updated_at:-1", "createdAt:-1", "createdAt:-1", "ts:-1", "username", "name"]
+    },
+    "idField": {
+      "type": "string",
+      "maxLength": 50,
+      "required": true,
+      "index": { "type": "primary" }
+    }
+  }
+}

package/bajo/hook/bajoI18N.db@before-resource-merge.js

@@ -0,0 +1,10 @@
+async function beforeResourceMerge (lng, content) {
+  const { eachPlugins, readConfig } = this.app.bajo
+  const { merge } = this.app.bajo.lib._
+  await eachPlugins(async function ({ file, ns }) {
+    const item = await readConfig(file, { ns })
+    merge(content, item)
+  }, { glob: `i18n/${lng}.json`, ns: this.name })
+}
+
+export default beforeResourceMerge

package/bajo/hook/bajoI18N@before-init.js

@@ -0,0 +1,6 @@
+async function bajoI18nBeforeInit () {
+  const config = this.app.bajoI18N.config
+  if (!config.fallbackNS.includes(this.name)) config.fallbackNS.push(this.name)
+}
+
+export default bajoI18nBeforeInit

package/bajo/init.js

@@ -0,0 +1,18 @@
+import collectConnections from '../lib/collect-connections.js'
+import collectDrivers from '../lib/collect-drivers.js'
+import collectFeature from '../lib/collect-feature.js'
+import collectSchemas from '../lib/collect-schemas.js'
+
+async function init () {
+  const { buildCollections } = this.app.bajo
+  const { fs } = this.app.bajo.lib
+  const cfg = this.config
+  fs.ensureDirSync(`${cfg.dir.data}/attachment`)
+  await collectDrivers.call(this)
+  this.connections = await buildCollections({ ns: this.name, handler: collectConnections, dupChecks: ['name'] })
+  if (this.connections.length === 0) this.log.warn('No %s found!', this.print.write('connection'))
+  await collectFeature.call(this)
+  await collectSchemas.call(this)
+}
+
+export default init

package/bajo/method/aggregate-types.js

@@ -0,0 +1 @@
+export default ['count', 'avg', 'min', 'max', 'sum']

package/bajo/method/attachment/copy-uploaded.js

@@ -0,0 +1,32 @@
+import path from 'path'
+
+async function copyUploaded (name, id, { req, setField, setFile, mimeType, stats, silent = true } = {}) {
+  const { fs } = this.app.bajo.lib
+  name = this.attachmentPreCheck(name)
+  if (!name) {
+    if (silent) return
+    throw this.error('Name must be provided')
+  }
+  if (!this.bajoWeb) {
+    if (silent) return
+    throw this.error('Plugin \'%s\' is missing')
+  }
+  const { dir, files } = await this.bajoWeb.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 }
+    const rec = await this.attachmentCreate(name, id, opts)
+    delete rec.dir
+    result.push(rec)
+    if (setField || setFile) break
+  }
+  fs.removeSync(dir)
+  return result
+}
+
+export default copyUploaded

package/bajo/method/attachment/create.js

@@ -0,0 +1,27 @@
+import mergeAttachmentInfo from '../../../lib/merge-attachment-info.js'
+
+async function create (name, id, options = {}) {
+  const { fs } = this.app.bajo.lib
+  name = this.attachmentPreCheck(name)
+  if (!name) return
+  const { source, field, file } = options
+  if (!source) throw this.error('Invalid 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 (req && req.flash) req.flash('dbsuccess', { message: req.i18n.t('File successfully uploaded') })
+  return rec
+}
+
+export default create

package/bajo/method/attachment/find.js

@@ -0,0 +1,27 @@
+import mergeAttachmentInfo from '../../../lib/merge-attachment-info.js'
+
+async function find (name, id, options = {}) {
+  const { fastGlob, fs } = this.app.bajo.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/bajo/method/attachment/get-path.js

@@ -0,0 +1,11 @@
+async function getPath (name, id, field, file, options = {}) {
+  const { pascalCase, getPluginDataDir } = this.app.bajo
+  const { fs } = this.app.bajo.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/bajo/method/attachment/get.js

@@ -0,0 +1,12 @@
+async function get (name, id, field, file, options = {}) {
+  name = this.attachmentPreCheck(name)
+  if (!name) return
+  const { find } = this.app.bajo.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/bajo/method/attachment/pre-check.js

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

package/bajo/method/attachment/remove.js

@@ -0,0 +1,11 @@
+async function remove (name, id, field, file, options = {}) {
+  const { fs } = this.app.bajo.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('dbsuccess', { message: req.i18n.t('File successfully removed') })
+}
+
+export default remove

package/bajo/method/attachment/update.js

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

package/bajo/method/build-match.js

@@ -0,0 +1,34 @@
+function split (value, schema) {
+  let [field, val] = value.split(':').map(i => i.trim())
+  if (!val) {
+    val = field
+    field = '*'
+  }
+  return { field, value: val }
+}
+
+function buildMatch ({ input = '', schema, options }) {
+  const { isPlainObject, trim } = this.app.bajo.lib._
+  input = trim(input)
+  let items = {}
+  if (isPlainObject(input)) items = input
+  else if (input[0] === '{') items = JSON.parse(input)
+  else {
+    for (const item of input.split('+').map(i => i.trim())) {
+      const part = split.call(this, item, schema)
+      if (!items[part.field]) items[part.field] = []
+      items[part.field].push(...part.value.split(' ').filter(v => ![''].includes(v)))
+    }
+  }
+  const matcher = {}
+  for (const f of schema.fullText.fields) {
+    const value = []
+    if (typeof items[f] === 'string') items[f] = [items[f]]
+    if (Object.prototype.hasOwnProperty.call(items, f)) value.push(...items[f])
+    matcher[f] = value
+  }
+  if (Object.prototype.hasOwnProperty.call(items, '*')) matcher['*'] = items['*']
+  return matcher
+}
+
+export default buildMatch

package/bajo/method/build-query.js

@@ -0,0 +1,13 @@
+import nql from '@tryghost/nql'
+
+async function buildQuery ({ filter, schema, options = {} } = {}) {
+  const { trim, isString, isPlainObject } = this.app.bajo.lib._
+  let query = {}
+  if (isString(filter.query)) {
+    if (trim(filter.query).startsWith('{')) query = JSON.parse(filter.query)
+    else query = nql(filter.query).parse()
+  } else if (isPlainObject(filter.query)) query = filter.query
+  return query
+}
+
+export default buildQuery

package/bajo/method/bulk/create.js

@@ -0,0 +1,45 @@
+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 { generateId, runHook, isSet } = this.app.bajo
+  const { clearColl } = this.cache ?? {}
+  const { find } = this.app.bajo.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}:onBeforeBulkCreate`, name, bodies, options)
+    await runHook(`${this.name}.${name}:onBeforeBulkCreate`, 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}:onAfterBulkCreate`, bodies, options)
+    await runHook(`${this.name}:onAfterBulkCreate`, name, bodies, options)
+  }
+  if (clearColl) await clearColl({ model: name })
+}
+
+export default create

package/bajo/method/get-info.js

@@ -0,0 +1,14 @@
+function getInfo (name) {
+  const { breakNsPath } = this.app.bajo
+  const { find, map } = this.app.bajo.lib._
+  const schema = this.getSchema(name)
+  const conn = find(this.connections, { name: schema.connection })
+  const [ns, type] = breakNsPath(conn.type)
+  const driver = find(this.drivers, { type, ns, driver: conn.driver })
+  const instance = find(this.app[driver.ns].instances, { name: schema.connection })
+  const opts = conn.type === 'mssql' ? { includeTriggerModifications: true } : undefined
+  const returning = [map(schema.properties, 'name'), opts]
+  return { instance, driver, connection: conn, returning, schema }
+}
+
+export default getInfo

package/bajo/method/get-schema.js

@@ -0,0 +1,10 @@
+function getSchema (input) {
+  const { find, isPlainObject, cloneDeep } = this.app.bajo.lib._
+  let name = isPlainObject(input) ? input.name : input
+  name = this.app.bajo.pascalCase(name)
+  const schema = find(this.schemas, { name })
+  if (!schema) throw this.error('Unknown model/schema \'%s\'', name)
+  return cloneDeep(schema)
+}
+
+export default getSchema

package/bajo/method/model/clear.js

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

package/bajo/method/model/create.js

@@ -0,0 +1,11 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+
+async function create (name, options = {}) {
+  const { runHook } = this.app.bajo
+  const { handler, schema } = await resolveMethod.call(this, name, 'model-create', options)
+  await runHook(`${this.name}:beforeCollCreate` + name, schema)
+  await handler.call(this, { schema, options })
+  await runHook(`${this.name}:afterCollCreate` + name, schema)
+}
+
+export default create

package/bajo/method/model/drop.js

@@ -0,0 +1,11 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+
+async function drop (name, options = {}) {
+  const { runHook } = this.app.bajo
+  const { handler, schema } = await resolveMethod.call(this, name, 'model-drop', options)
+  await runHook(`${this.name}:beforeCollDrop` + name, schema)
+  await handler.call(this, { schema, options })
+  await runHook(`${this.name}:afterCollDrop` + name, schema)
+}
+
+export default drop

package/bajo/method/model/exists.js

@@ -0,0 +1,17 @@
+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 { handler, schema } = await resolveMethod.call(this, name, 'model-exists', options)
+  await runHook(`${this.name}:beforeCollExists` + name, schema)
+  const exist = await handler.call(this, { schema, options })
+  await runHook(`${this.name}:afterCollExists` + name, schema, exist)
+  if (!exist && thrown) throw this.error('Model doesn\'t exist yet. Please do model rebuild first')
+  cache[name] = exist
+  return exist
+}
+
+export default exists

package/bajo/method/pick-record.js

@@ -0,0 +1,30 @@
+async function transform ({ record, schema, hidden = [] } = {}) {
+  const { dayjs } = this.app.bajo
+  if (record._id) {
+    record.id = record._id
+    delete record._id
+  }
+  const result = {}
+  for (const p of schema.properties) {
+    if (hidden.includes(p.name)) continue
+    result[p.name] = record[p.name] ?? null
+    if (record[p.name] === null) continue
+    switch (p.type) {
+      case 'time': result[p.name] = dayjs(record[p.name]).format('HH:mm:ss'); break
+      case 'date': result[p.name] = dayjs(record[p.name]).format('YYYY-MM-DD'); break
+    }
+  }
+  return await this.sanitizeBody({ body: result, schema, partial: true, ignoreNull: true })
+}
+
+async function pickRecord ({ record, fields, schema = {}, hidden = [] } = {}) {
+  const { isArray, pick, clone, isEmpty, omit } = this.app.bajo.lib._
+  if (isEmpty(record)) return record
+  if (hidden.length > 0) record = omit(record, hidden)
+  if (!isArray(fields)) return await transform.call(this, { record, schema, hidden })
+  const fl = clone(fields)
+  if (!fl.includes('id')) fl.unshift('id')
+  return pick(await transform.call(this, { record, schema, hidden }), fl)
+}
+
+export default pickRecord

package/bajo/method/prep-pagination.js

@@ -0,0 +1,66 @@
+function buildPageSkipLimit (filter) {
+  let limit = parseInt(filter.limit) || this.config.defaults.filter.limit
+  if (limit > this.config.defaults.filter.maxLimit) limit = this.config.defaults.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 }
+}
+
+function buildSort (input, schema, allowSortUnindexed) {
+  const { isEmpty, map, each, isPlainObject, isString, trim, filter, keys } = this.app.bajo.lib._
+  let sort
+  if (schema && isEmpty(input)) {
+    const columns = map(schema.properties, 'name')
+    each(this.config.defaults.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
+    }
+    if (schema) {
+      const indexes = map(filter(schema.properties, p => !!p.index), 'name')
+      each(schema.indexes, item => {
+        indexes.push(...item.fields)
+      })
+      const items = keys(sort)
+      each(items, i => {
+        if (!indexes.includes(i) && !allowSortUnindexed) throw this.error('Sort on unindexed field: \'%s@%s\'', i, schema.name)
+        // if (schema.fullText.fields.includes(i)) throw this.error('Can\'t sort on full-text index: \'%s@%s\'', i, schema.name)
+      })
+    }
+  }
+  return sort
+}
+
+async function prepPagination (filter = {}, schema, options = {}) {
+  const { page, skip, limit } = buildPageSkipLimit.call(this, filter)
+  let sortInput = filter.sort
+  try {
+    sortInput = JSON.parse(sortInput)
+  } catch (err) {}
+  const sort = buildSort.call(this, sortInput, schema, options.allowSortUnindexed)
+  return { limit, page, skip, sort }
+}
+
+export default prepPagination

package/bajo/method/prop-type.js

@@ -0,0 +1,43 @@
+const propType = {
+  integer: {
+    validator: 'number'
+  },
+  smallint: {
+    validator: 'number'
+  },
+  text: {
+    validator: 'string',
+    kind: 'text',
+    choices: ['text', 'mediumtext', 'longtext']
+  },
+  string: {
+    validator: 'string',
+    maxLength: 255,
+    minLength: 0
+  },
+  float: {
+    validator: 'number'
+  },
+  double: {
+    validator: 'number'
+  },
+  boolean: {
+    validator: 'boolean'
+  },
+  date: {
+    validator: 'date'
+  },
+  datetime: {
+    validator: 'date'
+  },
+  time: {
+    validator: 'date'
+  },
+  timestamp: {
+    validator: 'timestamp'
+  },
+  object: {},
+  array: {}
+}
+
+export default propType

package/bajo/method/record/clear.js

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

package/bajo/method/record/create.js

@@ -0,0 +1,61 @@
+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'
+
+async function create (name, input, opts = {}) {
+  const { generateId, runHook, isSet } = this.app.bajo
+  const { clearColl } = this.cache ?? {}
+  const { get, find, forOwn, cloneDeep } = this.app.bajo.lib._
+  const options = cloneDeep(opts)
+  options.dataOnly = options.dataOnly ?? true
+  input = cloneDeep(input)
+  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, hidden } = 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' })
+  if (!isSet(input.id)) {
+    if (idField.type === 'string') input.id = generateId()
+    else if (['integer', 'smallint'].includes(idField.type) && !idField.autoInc) input.id = generateId('int')
+  }
+  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, strict: true })
+  if (!noHook) {
+    await runHook(`${this.name}:onBeforeRecordCreate`, name, body, options)
+    await runHook(`${this.name}.${name}:onBeforeRecordCreate`, body, options)
+  }
+  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeCreate', { schema, body })
+  if (!noValidation) body = await execValidation.call(this, { noHook, name, body, options })
+  if (isSet(body.id) && !noCheckUnique) await checkUnique.call(this, { schema, body })
+  let record = {}
+  try {
+    const nbody = {}
+    forOwn(body, (v, k) => {
+      if (v === undefined) return undefined
+      const prop = find(schema.properties, { name: k })
+      if (options.truncateString && isSet(v) && prop && ['string', 'text'].includes(prop.type)) v = v.slice(0, prop.maxLength)
+      nbody[k] = v
+    })
+    record = await handler.call(this.app[driver.ns], { schema, body: nbody, 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.req.flash('dbsuccess', { message: this.print.write('Record successfully created'), record })
+    }
+  } catch (err) {
+    if (get(options, 'req.flash')) options.req.flash('dberr', err)
+    throw err
+  }
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterCreate', { schema, body, record })
+  if (!noHook) {
+    await runHook(`${this.name}.${name}:onAfterRecordCreate`, body, options, record)
+    await runHook(`${this.name}:onAfterRecordCreate`, name, body, options, record)
+  }
+  if (clearColl) await clearColl({ model: name, body, options, record })
+  if (noResult) return
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden })
+  return dataOnly ? record.data : record
+}
+
+export default create