dobo 2.0.1 → 2.2.0

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

@@ -0,0 +1,29 @@
+import { mergeAttachmentInfo } from './_util.js'
+const action = 'findAttachment'
+
+async function findAttachment (...args) {
+  if (!this.attachment) return
+  if (args.length === 0) return this.action(action, ...args)
+  const [id, opts = {}] = args
+  const { fastGlob, fs } = this.app.lib
+  const { getPluginDataDir } = this.app.bajo
+  const dir = `${getPluginDataDir(this.ns)}/attachment/${this.name}/${id}`
+  if (!fs.existsSync(dir)) return []
+  const files = await fastGlob(`${dir}/**/*`)
+  const { fullPath, stats, mimeType } = opts
+  const recs = []
+  for (const f of files) {
+    const item = f.replace(dir, '')
+    let [, fieldName, file] = item.split('/')
+    if (!file) {
+      file = fieldName
+      fieldName = null
+    }
+    const rec = { fieldName, file }
+    await mergeAttachmentInfo.call(this, rec, f, { mimeType, fullPath, stats })
+    recs.push(rec)
+  }
+  return recs
+}
+
+export default findAttachment

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

@@ -0,0 +1,19 @@
+const action = 'findOneRecord'
+
+async function findOneRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [params = {}, opts = {}] = args
+  const { cloneDeep } = this.app.lib._
+  const { dataOnly = true } = opts
+  if (dataOnly) opts.count = false
+  const nFilter = cloneDeep(params)
+  const nOptions = cloneDeep(opts)
+  nOptions.count = false
+  nOptions.dataOnly = false
+  nFilter.limit = 1
+  const result = await this.findRecord(nFilter, nOptions)
+  const data = result.data[0]
+  return dataOnly ? data : { data }
+}
+
+export default findOneRecord

package/{method/record/find.js → lib/factory/model/find-record.js}

@@ -1,115 +1,103 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import multiRelRows from '../../lib/multi-rel-rows.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-/**
- * @typedef {Object} TRecordFilter
- * @see Dobo#recordFind
- * @see Dobo#recordFindOne
- * @see Dobo#recordFindAll
- * @property {(string|Object)} [query={}] - Query definition. See {@tutorial query-language} for more
- * @property {number} limit - Max number of records per page
- * @property {number} page - Which page is the returned records currently at
- * @property {number} skip - Records to skip
- * @property {TRecordSort} sort - Sort order info
- */
-
-/**
- * @typedef {Object} TRecordFindResult
- * @see Dobo#recordFind
- * @see Dobo#recordFindAll
- * @see Dobo#recordGet
- * @property {Array.<Object>} data - Array of returned records
- * @property {boolean} success - Whether operation is successfull or failed
- * @property {number} page - Which page is the returned records currently at
- * @property {number} limit - Max number of records per page
- * @property {number} count - Total number of records returned
- * @property {number} pages - Total number of pages returned
- */
-
-/**
- * @typedef {Object} TRecordFindOptions
- * @see Dobo#recordFind
- * @see Dobo#recordFindOne
- * @see Dobo#recordFindAll
- * @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
- */
-
-/**
- * Find records by model's name and given filter
- *
- * Example: find records from model **CdbCountry** where its id is 'ID' or 'MY',
- * sorted by ```name``` in ascending order and return only its ```id```, ```name``` and ```iso3```
- * ```javascript
- * const { recordFind } = this.app.dobo
- * const query = { id: { $in: ['ID', 'MY'] } }
- * const sort = { name: 1 }
- * const fields = ['id', 'name', 'iso3']
- * const result = await recordFind('CdbCountry', { query, sort }, { fields })
- * ```
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordFind
- * @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 find (name, filter = {}, 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.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.ns}:beforeRecordFind`, name, filter, options)
-    await runHook(`${this.ns}.${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.ns}.${camelCase(name)}:afterRecordFind`, filter, options, records)
-    await runHook(`${this.ns}: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
+import { getFilterAndOptions, execHook, execModelHook, getMultiRefs } from './_util.js'
+const action = 'findRecord'
+
+/**
+ * @typedef {Object} TRecordFilter
+ * @see Dobo#recordFind
+ * @see Dobo#recordFindOne
+ * @see Dobo#recordFindAll
+ * @property {(string|Object)} [query={}] - Query definition. See {@tutorial query-language} for more
+ * @property {number} limit - Max number of records per page
+ * @property {number} page - Which page is the returned records currently at
+ * @property {number} skip - Records to skip
+ * @property {TRecordSort} sort - Sort order info
+ */
+
+/**
+ * @typedef {Object} TRecordFindResult
+ * @see Dobo#recordFind
+ * @see Dobo#recordFindAll
+ * @see Dobo#recordGet
+ * @property {Array.<Object>} data - Array of returned records
+ * @property {boolean} success - Whether operation is successfull or failed
+ * @property {number} page - Which page is the returned records currently at
+ * @property {number} limit - Max number of records per page
+ * @property {number} count - Total number of records returned
+ * @property {number} pages - Total number of pages returned
+ */
+
+/**
+ * @typedef {Object} TRecordFindOptions
+ * @see Dobo#recordFind
+ * @see Dobo#recordFindOne
+ * @see Dobo#recordFindAll
+ * @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 model
+ * @property {boolean} [forceNoHidden=false] - If ```true```, hidden fields will be ignored and ALL fields will be returned
+ */
+
+/**
+ * Find records by model's name and given filter
+ *
+ * Example: find records from model **CdbCountry** where its id is 'ID' or 'MY',
+ * sorted by ```name``` in ascending order and return only its ```id```, ```name``` and ```iso3```
+ * ```javascript
+ * const { recordFind } = this.app.dobo
+ * const query = { id: { $in: ['ID', 'MY'] } }
+ * const sort = { name: 1 }
+ * const fields = ['id', 'name', 'iso3']
+ * const result = await recordFind('CdbCountry', { query, sort }, { fields })
+ * ```
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @instance
+ * @name recordFind
+ * @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 findRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [params = {}, opts = {}] = args
+  const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
+  const { dataOnly = true } = opts
+  const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
+  if (dataOnly) options.count = false
+  let { noResultSanitizer, noCache } = options
+  if (!this.cacheable || !options.record) noCache = true
+  if (!noCache) {
+    try {
+      await runHook('cache:getByFilter', this, filter)
+    } catch (err) {
+      if (err.code === 'CACHED_RESULT') {
+        const result = err.payload
+        result.cache = true
+        return dataOnly ? result.data : result
+      }
+    }
+  }
+  await execHook.call(this, 'beforeFindRecord', filter, options)
+  await execModelHook.call(this, 'beforeFindRecord', filter, options)
+  const result = options.record ?? (await this.driver._findRecord(this, filter, options)) ?? {}
+  if (!noResultSanitizer) {
+    for (const idx in result.data) {
+      result.data[idx] = await this.sanitizeRecord(result.data[idx], options)
+    }
+  }
+  if (isSet(options.refs)) await getMultiRefs.call(this, { records: result.data, options })
+  await execModelHook.call(this, 'afterFindRecord', filter, result, options)
+  await execHook.call(this, 'afterFindRecord', filter, result, options)
+  if (!noCache) await runHook('cache:setByFilter', this, filter, result)
+  return dataOnly ? result.data : result
+}
+
+export default findRecord

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

@@ -0,0 +1,15 @@
+const action = 'getAttachment'
+
+async function getAttachment (...args) {
+  if (!this.attachment) return
+  if (args.length === 0) return this.action(action, ...args)
+  let [id, fieldName, file, opts = {}] = args
+  const { find } = this.app.lib._
+  const all = await this.findAttachment(id, opts)
+  if (fieldName === 'null') fieldName = null
+  const data = find(all, { fieldName, file })
+  if (!data) throw this.error('notFound', { statusCode: 404 })
+  return data
+}
+
+export default getAttachment

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

@@ -0,0 +1,79 @@
+import { getFilterAndOptions, execHook, execModelHook, getSingleRef } from './_util.js'
+const action = 'getRecord'
+
+/**
+ * @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} TRecordgetFilterAndOptions
+ * @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 model
+ * @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 {TRecordgetFilterAndOptions} [options={}]
+ * @returns {(TRecordGetResult|Object)} Return record's ```object``` if ```options.dataOnly``` is set. {@link TRecordGetResult} otherwise
+ */
+async function getRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  let [id, opts = {}] = args
+  const { isEmpty } = this.app.lib._
+  const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  let { noResultSanitizer, noCache } = options
+  if (!this.cacheable || !options.record) noCache = true
+  id = this.sanitizeId(id)
+  await execHook.call(this, 'beforeGetRecord', id, options)
+  await execModelHook.call(this, 'beforeGetRecord', id, options)
+  if (!noCache) {
+    try {
+      await runHook('cache:getById', this, id)
+    } catch (err) {
+      if (err.code === 'CACHED_RESULT') {
+        const result = err.payload
+        result.cache = true
+        return dataOnly ? result.data : result
+      }
+    }
+  }
+  const result = options.record ?? (await this.driver._getRecord(this, id, options)) ?? {}
+  if (isEmpty(result.data) && !options.throwNotFound) return dataOnly ? undefined : { data: undefined }
+  if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
+  if (isSet(options.refs)) await getSingleRef.call(this, { record: result.data, options })
+  await execModelHook.call(this, 'afterGetRecord', id, result.data, options)
+  await execHook.call(this, 'afterGetRecord', id, result, options)
+  if (!noCache) await runHook('cache:setById', this, id, result)
+  return dataOnly ? result.data : result
+}
+
+export default getRecord

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

@@ -0,0 +1,37 @@
+import path from 'path'
+const action = 'listAttachment'
+
+async function listAttachment (...args) {
+  if (!this.attachment) return
+  if (args.length === 0) return this.action(action, ...args)
+  const [params = {}, opts = {}] = args
+  const { map, kebabCase } = this.app.lib._
+  const { importPkg, getPluginDataDir } = this.app.bajo
+  const mime = await importPkg('waibu:mime')
+  const { fastGlob } = this.app.lib
+
+  const { id = '*', fieldName = '*', file = '*' } = params
+  const { uriEncoded = true } = opts
+  const root = `${getPluginDataDir('dobo')}/attachment`
+  let pattern = `${root}/${this.name}/${id}/${fieldName}/${file}`
+  if (uriEncoded) pattern = pattern.split('/').map(p => decodeURI(p)).join('/')
+  return map(await fastGlob(pattern), f => {
+    const mimeType = mime.getType(path.extname(f)) ?? ''
+    const fullPath = f.replace(root, '')
+    const row = {
+      file: f,
+      fileName: path.basename(fullPath),
+      fullPath,
+      mimeType,
+      params: { model: this.name, id, fieldName, file }
+    }
+    if (this.app.waibuMpa) {
+      const { routePath } = this.app.waibu
+      const [, _model, _id, _fieldName, _file] = fullPath.split('/')
+      row.url = routePath(`dobo:/attachment/${kebabCase(_model)}/${_id}/${_fieldName}/${_file}`)
+    }
+    return row
+  })
+}
+
+export default listAttachment

package/lib/{add-fixtures.js → factory/model/load-fixtures.js}

@@ -1,67 +1,69 @@
-import path from 'path'
-
-async function addFixture (name, { spinner } = {}) {
-  const { resolvePath, readConfig, eachPlugins, getPluginDataDir } = this.app.bajo
-  const { isEmpty, isArray, isString } = this.app.lib._
-  const { fs } = this.app.lib
-  const { schema, connection } = this.getInfo(name)
-  if (connection.proxy) {
-    this.log.warn('proxiedConnBound%s', schema.name)
-    return
-  }
-  const result = { success: 0, failed: 0 }
-  const base = path.basename(schema.file, path.extname(schema.file))
-  // original
-  const pattern = resolvePath(`${path.dirname(schema.file)}/../fixture/${base}.*`)
-  let items = await readConfig(pattern, { ns: schema.ns, ignoreError: true })
-  if (isEmpty(items)) items = []
-  // override
-  const overrides = await readConfig(`${this.app.main.dir.pkg}/extend/dobo/override/${schema.ns}/fixture/${base}.*`, { ns: this.ns, ignoreError: true })
-
-  if (isArray(overrides) && !isEmpty(overrides)) items = overrides
-  // extend
-  await eachPlugins(async function ({ dir }) {
-    const { ns } = this
-    const extend = await readConfig(`${dir}/extend/dobo/extend/${schema.ns}/fixture/${base}.*`, { ns, ignoreError: true })
-    if (isArray(extend) && !isEmpty(extend)) items.push(...extend)
-  })
-  if (isEmpty(items)) return result
-  const opts = { noHook: true, noCache: true }
-  for (const item of items) {
-    try {
-      for (const k in item) {
-        const v = item[k]
-        if (typeof v === 'string' && v.slice(0, 2) === '?:') {
-          let [, model, field, ...query] = v.split(':')
-          if (!field) field = 'id'
-          const recs = await this.recordFind(model, { query: query.join(':') }, opts)
-          item[k] = (recs[0] ?? {})[field]
-        }
-        if (v === null) item[k] = undefined
-      }
-      const resp = await this.recordCreate(schema.name, item, { force: true })
-      if (isArray(item._attachments) && item._attachments.length > 0) {
-        for (let att of item._attachments) {
-          if (isString(att)) att = { field: 'file', file: att }
-          const fname = path.basename(att.file)
-          if (fs.existsSync(att.file)) {
-            const dest = `${getPluginDataDir(schema.ns)}/${resp.id}/${att.field}/${fname}`
-            try {
-              fs.copySync(att.file, dest)
-            } catch (err) {}
-          }
-        }
-      }
-      result.success++
-      if (spinner) spinner.setText('recordsAdded%s%d%d', schema.name, result.success, items.length)
-    } catch (err) {
-      console.log(err)
-      err.model = schema.name
-      if (this.app.applet) this.print.fail(this.validationErrorMessage(err))
-      result.failed++
-    }
-  }
-  return result
-}
-
-export default addFixture
+import path from 'path'
+
+async function loadFixtures ({ spinner } = {}) {
+  const { readConfig, eachPlugins, getPluginDataDir } = this.app.bajo
+  const { resolvePath } = this.app.lib.aneka
+  const { isEmpty, isArray, isString } = this.app.lib._
+  const { fs } = this.app.lib
+  if (this.connection.proxy) {
+    this.log.warn('proxiedConnBound%s', this.name)
+    return
+  }
+  const result = { success: 0, failed: 0 }
+  const base = path.basename(this.file, path.extname(this.file))
+  // original
+  const pattern = resolvePath(`${path.dirname(this.file)}/../fixture/${base}.*`)
+  let items = await readConfig(pattern, { ns: this.plugin.ns, ignoreError: true })
+  if (isEmpty(items)) items = []
+  // override
+  const overrides = await readConfig(`${this.app.main.dir.pkg}/extend/dobo/override/${this.plugin.ns}/fixture/${base}.*`, { ns: this.plugin.ns, ignoreError: true })
+
+  if (isArray(overrides) && !isEmpty(overrides)) items = overrides
+  // extend
+  const me = this
+  await eachPlugins(async function ({ dir }) {
+    const { ns } = this
+    const extend = await readConfig(`${dir}/extend/dobo/extend/${me.plugin.ns}/fixture/${base}.*`, { ns, ignoreError: true })
+    if (isArray(extend) && !isEmpty(extend)) items.push(...extend)
+  })
+  if (isEmpty(items)) return result
+  const opts = { noHook: true, noCache: true }
+  for (const item of items) {
+    try {
+      for (const k in item) {
+        const v = item[k]
+        if (typeof v === 'string' && v.slice(0, 2) === '?:') {
+          let [, model, field, ...query] = v.split(':')
+          if (!field) field = 'id'
+          const ref = this.app.dobo.getModel(model)
+          const recs = await ref.findRecord({ query: query.join(':') }, opts)
+          item[k] = (recs[0] ?? {})[field]
+        }
+        if (v === null) item[k] = undefined
+      }
+      const resp = await this.createRecord(item, { force: true })
+      if (isArray(item._attachments) && item._attachments.length > 0) {
+        for (let att of item._attachments) {
+          if (isString(att)) att = { field: 'file', file: att }
+          const fname = path.basename(att.file)
+          if (fs.existsSync(att.file)) {
+            const dest = `${getPluginDataDir(this.plugin.ns)}/${resp.id}/${att.field}/${fname}`
+            try {
+              fs.copySync(att.file, dest)
+            } catch (err) {}
+          }
+        }
+      }
+      result.success++
+      if (spinner) spinner.setText('recordsAdded%s%d%d', this.name, result.success, items.length)
+    } catch (err) {
+      console.log(err)
+      err.model = this.name
+      if (this.app.applet) this.plugin.print.fail(this.app.dobo.validationErrorMessage(err))
+      result.failed++
+    }
+  }
+  return result
+}
+
+export default loadFixtures

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

@@ -0,0 +1,15 @@
+import { getAttachmentPath } from './_util.js'
+const action = 'removeAttachment'
+
+async function removeAttachment (...args) {
+  if (!this.attachment) return
+  if (args.length === 0) return this.action(action, ...args)
+  const [id, fieldName, file, opts = {}] = args
+  const { fs } = this.app.lib
+  const path = await getAttachmentPath.call(this, id, fieldName, file)
+  const { req } = opts
+  await fs.remove(path)
+  if (!opts.noFlash && req && req.flash) req.flash('notify', req.t('attachmentRemoved'))
+}
+
+export default removeAttachment

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

@@ -0,0 +1,59 @@
+import { getFilterAndOptions, execHook, execModelHook, getSingleRef, handleReq } from './_util.js'
+const action = 'removeRecord'
+
+/**
+ * @typedef {Object} TRecordRemoveOptions
+ * @see Dobo#recordRemove
+ * @property {boolean} [dataOnly=true] - If ```true``` (default) returns deleted record. Otherwise {@link TRecordRemoveResult}
+ * @property {boolean} [noHook=false] - If ```true```, no model's hook will be executed
+ * @property {boolean} [noModelHook=false] - If ```true```, no model's feature hook will be executed
+ * @property {boolean} [noResult=false] - If ```true```, returns nothing
+ * @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 model
+ * @property {boolean} [forceNoHidden=false] - If ```true```, hidden fields will be ignored and ALL fields will be returned
+ */
+
+/**
+ * Remove existing record by it's ID. All attachments bound to this record will also be removed forever.
+ *
+ * Example:
+ * ```javascript
+ * const { recordRemove } = this.app.dobo
+ * const result = await recordRemove('CdbCountry', 'ID')
+ * ```
+ *
+ * @method
+ * @memberof Model
+ * @async
+ * @instance
+ * @name removeRecord
+ * @param {(string|number)} id - Record's ID
+ * @param {TRecordRemoveOptions} [options={}]
+ * @returns {(TRecordRemoveResult|Object)} Return the removed record if ```options.dataOnly``` is set. {@link TRecordRemoveResult} otherwise
+ */
+async function removeRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  let [id, opts = {}] = args
+  const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  const { noResult, noResultSanitizer } = options
+  id = this.sanitizeId(id)
+  await execHook.call(this, 'beforeRemoveRecord', id, options)
+  await execModelHook.call(this, 'beforeRemoveRecord', id, options)
+  const result = options.record ?? (await this.driver._removeRecord(this, id, options)) ?? {}
+  if (noResult) {
+    await runHook('cache:clear', this, 'remove', id)
+    return
+  }
+  if (!noResultSanitizer) result.oldData = await this.sanitizeRecord(result.oldData, options)
+  if (isSet(options.refs)) await getSingleRef.call(this, { record: result.data, options })
+  await handleReq.call(this, result.oldData.id, 'removed', options)
+  await execModelHook.call(this, 'afterRemoveRecord', id, result, options)
+  await execHook.call(this, 'afterRemoveRecord', id, result, options)
+  await runHook('cache:clear', this, 'remove', id, result)
+  return dataOnly ? result.oldData : result
+}
+
+export default removeRecord