dobo 2.0.1 → 2.2.0

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.app.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.app.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.app.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.app.lib.aneka
-  const { generateId, runHook } = this.app.bajo
-  const { clearModel } = this.cache ?? {}
-  const { find } = this.app.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.ns}:beforeBulkCreate`, name, bodies, options)
-    await runHook(`${this.ns}.${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.ns}.${name}:afterBulkCreate`, bodies, options)
-    await runHook(`${this.ns}: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.app.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.ns}:beforeModelClear`, schema, options)
-    await runHook(`${this.ns}.${camelCase(name)}:beforeModelClear`, options)
-  }
-  const resp = await handler.call(this.app[driver.ns], { schema, options })
-  if (!noHook) {
-    await runHook(`${this.ns}.${camelCase(name)}:afterModelClear`, options, resp)
-    await runHook(`${this.ns}:afterModelClear`, schema, options, resp)
-  }
-  return resp
-}
-
-export default clear

package/method/model/create.js

@@ -1,32 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-/**
- * Create a new model:
- * - read corresponding schema
- * - attempt to create table/database/collection accordingly
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name modelCreate
- * @param {string} name - Model's name
- * @param {Object} [options={}] - Options object
- */
-async function create (name, options = {}) {
-  const { runHook } = this.app.bajo
-  const { camelCase } = this.app.lib._
-
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-create', options)
-  if (!options.noHook) {
-    await runHook(`${this.ns}:beforeModelCreate`, schema, options)
-    await runHook(`${this.ns}.${camelCase(name)}:beforeModelCreate`, options)
-  }
-  await handler.call(this.app[driver.ns], { schema, options })
-  if (!options.noHook) {
-    await runHook(`${this.ns}.${camelCase(name)}:afterModelCreate`, options)
-    await runHook(`${this.ns}:afterModelCreate`, schema, options)
-  }
-}
-
-export default create

package/method/model/drop.js

@@ -1,31 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-/**
- * Drop database model
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name modelDrop
- * @param {string} name - Model's name
- * @param {Object} [options={}] - Options object
- */
-
-async function drop (name, options = {}) {
-  const { runHook } = this.app.bajo
-  const { camelCase } = this.app.lib._
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-drop', options)
-
-  if (!options.noHook) {
-    await runHook(`${this.ns}:beforeModelDrop`, schema, options)
-    await runHook(`${this.ns}.${camelCase(name)}:beforeModelDrop`, options)
-  }
-  await handler.call(this.app[driver.ns], { schema, options })
-  if (!options.noHook) {
-    await runHook(`${this.ns}.${camelCase(name)}:afterModelDrop`, options)
-    await runHook(`${this.ns}:afterModelDrop`, schema, options)
-  }
-}
-
-export default drop

package/method/model/exists.js

@@ -1,37 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-const cache = {}
-
-/**
- * Check if model exists already
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name modelExists
- * @param {string} name - Model's name
- * @param {boolean} [thrown=false] - If ```true``` throw error if not exists instead of just silent
- * @param {Object} [options={}] - Options object
- * @returns {boolean}
- */
-async function exists (name, thrown, options = {}) {
-  if (cache[name]) return cache[name]
-  const { runHook } = this.app.bajo
-  const { camelCase } = this.app.lib._
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-exists', options)
-  if (!options.noHook) {
-    await runHook(`${this.ns}:beforeModelExists`, schema, options)
-    await runHook(`${this.ns}.${camelCase(name)}:beforeModelExists`, options)
-  }
-  const exist = await handler.call(this.app[driver.ns], { schema, options })
-  if (!options.noHook) {
-    await runHook(`${this.ns}.${camelCase(name)}:afterModelExists`, exist, options)
-    await runHook(`${this.ns}: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.app.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.ns}:beforeRecordClear`, name, options)
-    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordClear`, options)
-  }
-  const resp = await handler.call(this.app[driver.ns], { schema, options })
-  if (!noHook) {
-    await runHook(`${this.ns}.${camelCase(name)}:afterRecordClear`, options, resp)
-    await runHook(`${this.ns}:afterRecordClear`, name, options, resp)
-  }
-  return resp
-}
-
-export default clear

package/method/record/count.js

@@ -1,66 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-/**
- * @typedef {Object} TRecordCountOptions
- * @see Dobo#recordCount
- * @property {boolean} [dataOnly=true] - If ```true``` (default) returns array of records. Otherwise {@link TFindRecordResult}
- * @property {boolean} [noCache=true] - If ```true``` (default), result set won't be cached. This will overwrite model's ```cacheable``` property. Only applicable if {@link https://github.com/ardhi/bajo-cache|bajo-cache} is loaded
- * @property {boolean} [noHook=false] - If ```true```, no model's hook will be executed
- * @property {boolean} [noFeatureHook=false] - If ```true```, no model's feature hook will be executed
- */
-
-/**
- * Return the number of records found by given filter
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordCount
- * @param {string} name - Model's name
- * @param {TRecordFilter} [filter={}] - Filter object
- * @param {TRecordCountOptions} [options={}]
- * @returns {(TRecordCountResult|number)} Return ```number``` of records if ```options.dataOnly``` is set. {@link TRecordCountResult} otherwise
- */
-async function count (name, filter = {}, opts = {}) {
-  const { runHook } = this.app.bajo
-  const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.app.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.ns}:beforeRecordCount`, name, filter, options)
-    await runHook(`${this.ns}.${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.ns}.${camelCase(name)}:afterRecordCount`, filter, options, record)
-    await runHook(`${this.ns}: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,111 +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'
-
-/**
- * @typedef {Object} TRecordCreateOptions
- * @see Dobo#recordCreate
- * @property {boolean} [dataOnly=true] - If ```true``` (default) returns record's object. Otherwise {@link TRecordCreateResult}
- * @property {boolean} [noHook=false] - If ```true```, no model's hook will be executed
- * @property {boolean} [noFeatureHook=false] - If ```true```, no model's feature hook will be executed
- * @property {boolean} [noValidation=false] - If ```true```, no validation of data payload performed
- * @property {boolean} [noCheckUnique=false] - If ```true```, no unique validation for ID performed
- * @property {boolean} [noSanitize=false] - If ```true```, accept data payload as is without sanitization
- * @property {boolean} [noResult=false] - If ```true```, returns nothing
- * @property {boolean} [truncateString=true] - If ```true``` (default), string is truncated to its schema's ```maxLemngth```
- * @property {boolean} [fields=[]] - If not empty, return only these fields EXCLUDING hidden fields
- * @property {boolean} [hidden=[]] - Additional fields to hide, in addition the one set in model's schema
- * @property {boolean} [forceNoHidden=false] - If ```true```, hidden fields will be ignored and ALL fields will be returned
- */
-
-/**
- * Create a new record
- *
- * Example:
- * ```javascript
- * const { recordCreate } = this.app.dobo
- * const { body } = {
- *   id: 'ID',
- *   name: 'Indonesia',
- *   iso3: 'IDN'
- * }
- * const result = await recordCreate('CdbCountry', body)
- * ```
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordCreate
- * @param {string} name - Model's name
- * @param {Object} body - Data to be saved
- * @param {TRecordCreateOptions} [options={}]
- * @returns {(TRecordCreateResult|Object)} Returns newly created record if ```options.dataOnly``` is set. {@link TRecordCreateResult} otherwise
- */
-async function create (name, input, opts = {}) {
-  const { generateId, runHook } = this.app.bajo
-  const { isSet } = this.app.lib.aneka
-  const { clearModel } = this.cache ?? {}
-  const { find, forOwn, cloneDeep, camelCase, omit, get, pick } = this.app.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.ns}:beforeRecordCreate`, name, body, options)
-    await runHook(`${this.ns}.${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.ns}.${camelCase(name)}:afterRecordCreate`, nbody, options, record)
-    await runHook(`${this.ns}: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

package/method/record/find-all.js

@@ -1,41 +0,0 @@
-/**
- * Find all records by model's name and given filter.
- *
- * The total number of records returned is limited by ```hardLimit``` value set in {@tutorial config} file.
- *
- * @see Dobo#recordFind
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordFindAll
- * @param {string} name - Model's name
- * @param {Object} [filter={}] - Filter object
- * @param {TRecordFindOptions} [options={}]
- * @returns {(TRecordFindResult|Array.<Object>)} Return ```array``` of records if ```options.dataOnly``` is set. {@link TRecordFindResult} otherwise
- */
-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,70 +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'
-
-/**
- * Find the first record by model's name and given filter.
- *
- * @see Dobo#recordFind
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordFindOne
- * @param {string} name - Model's name
- * @param {Object} [filter={}] - Filter object
- * @param {TRecordFindOptions} [options={}]
- * @returns {(TRecordGetResult|Object)} Return record's ```object``` if ```options.dataOnly``` is set. {@link TRecordGetResult} otherwise
- */
-async function findOne (name, filter = {}, opts = {}) {
-  const { isSet } = this.app.lib.aneka
-  const { runHook } = this.app.bajo
-  const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit, pick } = this.app.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.ns}:beforeRecordFindOne`, name, filter, options)
-    await runHook(`${this.ns}.${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.ns}.${camelCase(name)}:afterRecordFindOne`, filter, options, record)
-    await runHook(`${this.ns}: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/get.js

@@ -1,89 +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'
-
-/**
- * @typedef {Object} TRecordGetResult
- * @see Dobo#recordGet
- * @see Dobo#recordFindOne
- * @property {Object} data - Returned record
- * @property {boolean} success - Whether operation is successfull or failed
- */
-
-/**
- * @typedef {Object} TRecordGetOptions
- * @see Dobo#recordGet
- * @property {boolean} [dataOnly=true] - If ```true``` (default) returns array of records. Otherwise {@link TFindRecordResult}
- * @property {boolean} [count=false] - If ```true``` and ```dataOnly``` is also ```true```, the total number of records found will be returned
- * @property {boolean} [noCache=true] - If ```true``` (default), result set won't be cached. This will overwrite model's ```cacheable``` property. Only applicable if {@link https://github.com/ardhi/bajo-cache|bajo-cache} is loaded
- * @property {boolean} [noHook=false] - If ```true```, no model's hook will be executed
- * @property {boolean} [noFeatureHook=false] - If ```true```, no model's feature hook will be executed
- * @property {boolean} [fields=[]] - If not empty, return only these fields EXCLUDING hidden fields
- * @property {boolean} [hidden=[]] - Additional fields to hide, in addition the one set in model's schema
- * @property {boolean} [forceNoHidden=false] - If ```true```, hidden fields will be ignored and ALL fields will be returned
- */
-
-/**
- * Get record by model's name and record ID
- *
- * Example:
- * ```javascript
- * const { recordGet } = this.app.dobo
- * const fields = ['id', 'name', 'iso3']
- * const result = await recordGet('CdbCountry', 'ID', { fields })
- * ```
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordGet
- * @param {string} name - Model's name
- * @param {(string|number)} - Record's ID
- * @param {TRecordGetOptions} [options={}]
- * @returns {(TRecordGetResult|Object)} Return record's ```object``` if ```options.dataOnly``` is set. {@link TRecordGetResult} otherwise
- */
-
-async function get (name, id, opts = {}) {
-  const { isSet } = this.app.lib.aneka
-  const { runHook } = this.app.bajo
-  const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.app.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.ns}:beforeRecordGet`, name, id, options)
-    await runHook(`${this.ns}.${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.ns}.${camelCase(name)}:afterRecordGet`, id, options, record)
-    await runHook(`${this.ns}: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