dobo 1.2.10 → 2.0.1

package/{plugin-method → method}/record/count.js

@@ -1,10 +1,32 @@
 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.lib._
+  const { cloneDeep, camelCase, omit } = this.app.lib._
   delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
@@ -19,8 +41,8 @@ async function count (name, filter = {}, opts = {}) {
   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)
+    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) {
@@ -33,8 +55,8 @@ async function count (name, filter = {}, opts = {}) {
   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)
+    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 })

package/{plugin-method → method}/record/create.js

@@ -6,11 +6,51 @@ 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.lib.aneka
+  const { isSet } = this.app.lib.aneka
   const { clearModel } = this.cache ?? {}
-  const { find, forOwn, cloneDeep, camelCase, omit, get, pick } = this.lib._
+  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
@@ -26,8 +66,8 @@ async function create (name, input, opts = {}) {
   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)
+    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') {
@@ -61,8 +101,8 @@ async function create (name, input, opts = {}) {
   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)
+    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

package/{plugin-method → method}/record/find-all.js

@@ -1,3 +1,19 @@
+/**
+ * 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

package/{plugin-method → method}/record/find-one.js

@@ -2,11 +2,25 @@ 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.lib.aneka
+  const { isSet } = this.app.lib.aneka
   const { runHook } = this.app.bajo
   const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit, pick } = this.lib._
+  const { cloneDeep, camelCase, omit, pick } = this.app.lib._
   delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
@@ -24,8 +38,8 @@ async function findOne (name, filter = {}, opts = {}) {
   if (options.queryHandler) filter.query = await options.queryHandler.call(opts.req ? this.app[opts.req.ns] : this, filter.query, opts.req)
   filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
   if (!noHook) {
-    await runHook(`${this.name}:beforeRecordFindOne`, name, filter, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordFindOne`, filter, options)
+    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) {
@@ -45,8 +59,8 @@ async function findOne (name, filter = {}, opts = {}) {
   record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   record = pick(record, ['data'])
   if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordFindOne`, filter, options, record)
-    await runHook(`${this.name}:afterRecordFindOne`, name, filter, options, record)
+    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 })

package/method/record/find.js

@@ -0,0 +1,115 @@
+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

package/method/record/get.js

@@ -0,0 +1,89 @@
+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

package/method/record/remove.js

@@ -0,0 +1,72 @@
+import resolveMethod from '../../lib/resolve-method.js'
+import handleAttachmentUpload from '../../lib/handle-attachment-upload.js'
+import execFeatureHook from '../../lib/exec-feature-hook.js'
+
+/**
+ * @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} [noFeatureHook=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 schema
+ * @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 Dobo
+ * @async
+ * @instance
+ * @name recordRemove
+ * @param {string} name - Model's name
+ * @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 remove (name, id, opts = {}) {
+  const { runHook } = this.app.bajo
+  const { clearModel } = 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
+  const { fields, dataOnly, noHook, noResult, noFeatureHook, hidden, forceNoHidden } = options
+  options.dataOnly = false
+  await this.modelExists(name, true)
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-remove', options)
+  id = this.sanitizeId(id, schema)
+  if (!noHook) {
+    await runHook(`${this.ns}:beforeRecordRemove`, name, id, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordRemove`, id, options)
+  }
+  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeRemove', { schema, id, options })
+  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, options }))
+  delete options.record
+  if (options.req) {
+    if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, options, action: 'remove' })
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordRemoved'))
+  }
+  if (clearModel) await clearModel({ model: name, id, options, record })
+  if (noResult) return
+  record.oldData = options.record ? options.record.oldData : (await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden }))
+  if (!noHook) {
+    await runHook(`${this.ns}.${camelCase(name)}:afterRecordRemove`, id, options, record)
+    await runHook(`${this.ns}:afterRecordRemove`, name, id, options, record)
+  }
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterRemove', { schema, id, options, record })
+  return dataOnly ? record.oldData : record
+}
+
+export default remove

package/{plugin-method → method}/record/update.js

@@ -5,11 +5,52 @@ 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} TRecordUpdateOptions
+ * @see Dobo#recordUpdate
+ * @property {boolean} [dataOnly=true] - If ```true``` (default) returns record's object. Otherwise {@link TRecordUpdateResult}
+ * @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} [partial=true] - If ```true``` (default), only updated values are saved. Otherwise replace all existing values with given payload
+ * @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
+ */
+
+/**
+ * Update a record by it's ID and body payload
+ *
+ * Example:
+ * ```javascript
+ * const { recordUpdate } = this.app.dobo
+ * const { body } = {
+ *   name: 'Republic of Indonesia',
+ *   phoneCode: '+62'
+ * }
+ * const result = await recordUpdate('CdbCountry', 'ID', body)
+ * ```
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @instance
+ * @name recordUpdate
+ * @param {string} name - Model's name
+ * @param {(string|number)} id - Record's ID
+ * @param {Object} body - Body payload
+ * @param {TRecordUpdateOptions} [options={}]
+ * @returns {(TRecordUpdateResult|Object)} Returns updated record if ```options.dataOnly``` is set. {@link TRecordUpdateResult} otherwise
+ */
 async function update (name, id, input, opts = {}) {
-  const { isSet } = this.lib.aneka
+  const { isSet } = this.app.lib.aneka
   const { runHook } = this.app.bajo
   const { clearModel } = this.cache ?? {}
-  const { forOwn, find, cloneDeep, camelCase, omit, get } = this.lib._
+  const { forOwn, find, cloneDeep, camelCase, omit, get } = this.app.lib._
   delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
@@ -26,8 +67,8 @@ async function update (name, id, input, opts = {}) {
   let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, partial, strict: true, extFields })
   delete body.id
   if (!noHook) {
-    await runHook(`${this.name}:beforeRecordUpdate`, name, id, body, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordUpdate`, id, body, options)
+    await runHook(`${this.ns}:beforeRecordUpdate`, name, id, body, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordUpdate`, id, body, options)
   }
   if (!noValidation) body = await execValidation.call(this, { name, body, options, partial })
   if (!noCheckUnique) await checkUnique.call(this, { schema, body, id })
@@ -53,8 +94,8 @@ async function update (name, id, input, opts = {}) {
   record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
   record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
-    await runHook(`${this.name}:afterRecordUpdate`, name, id, nbody, options, record)
+    await runHook(`${this.ns}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
+    await runHook(`${this.ns}:afterRecordUpdate`, name, id, nbody, options, record)
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
   return dataOnly ? record.data : record

package/{plugin-method → method}/record/upsert.js

@@ -1,7 +1,23 @@
+/**
+ * Update a record by payload's ID. If no record is found by given ID, a new one will be created instead.
+ *
+ * Missing ID in payload always results a new record creation.
+ * ```
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @instance
+ * @name recordUpsert
+ * @param {string} name - Model's name
+ * @param {Object} body - Body payload
+ * @param {TRecordUpsertOptions} [options={}]
+ * @returns {(TRecordUpdateResult|TRecordCreateResult|Object)} Returns updated/newly created record if ```options.dataOnly``` is set. {@link TRecordUpdateResult} or {@link TRecordCreateResult} otherwise
+ */
 async function upsert (name, input, opts = {}) {
   const { generateId } = this.app.bajo
-  const { find } = this.lib._
-  const { cloneDeep, omit, merge } = this.lib._
+  const { find } = this.app.lib._
+  const { cloneDeep, omit, merge } = this.app.lib._
   const { query, omitOnUpdate = [], omitOnCreate = [] } = opts
   const options = cloneDeep(omit(opts, ['req', 'reply', 'query', 'omitOnUpdate', 'omitOnCreate']))
   options.req = opts.req

package/{plugin-method → method}/sanitize/body.js

@@ -1,8 +1,23 @@
+/**
+ * Sanitize payload body against schema
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @param {Object} [options={}]
+ * @param {Object} [options.body={}]
+ * @param {Object} [options.schema={}]
+ * @param {boolean} [options.partial=false]
+ * @param {boolean} [options.strict=false]
+ * @param {Array} [options.extFields=[]]
+ * @returns {Object}
+ */
+
 async function sanitizeBody ({ body = {}, schema = {}, partial, strict, extFields = [] }) {
-  const { isSet } = this.lib.aneka
-  const { dayjs } = this.lib
+  const { isSet } = this.app.lib.aneka
+  const { dayjs } = this.app.lib
   const { callHandler } = this.app.bajo
-  const { has, isString, isNumber, concat, isNaN } = this.lib._
+  const { has, isString, isNumber, concat, isNaN } = this.app.lib._
   const result = {}
   for (const p of concat(schema.properties, extFields)) {
     if (partial && !has(body, p.name)) continue

package/method/sanitize/date.js

@@ -0,0 +1,27 @@
+/**
+ * Sanitize value as a date/time value. Parse/format string using {@link https://day.js.org/docs/en/display/format|dayjs format}
+ *
+ * @method
+ * @memberof Dobo
+ * @param {(number|string)} value - Value to sanitize
+ * @param {Object} [options={}] - Options object
+ * @param {boolean} [options.silent=true] - If ```true``` (default) and value isn't valid, returns empty
+ * @param {string} [options.inputFormat] - If provided, parse value using this option
+ * @param {string} [options.outputFormat] - If not provided or ```native```, returns Javascript Date. Otherwise returns formatted date/time string
+ * @returns {(string|Date)}
+ */
+
+function sanitizeDate (value, { inputFormat, outputFormat, silent = true } = {}) {
+  const { dayjs } = this.app.lib
+  if (value === 0) return null
+  if (!outputFormat) outputFormat = inputFormat
+  const dt = dayjs(value, inputFormat)
+  if (!dt.isValid()) {
+    if (silent) return null
+    throw this.error('invalidDate')
+  }
+  if (outputFormat === 'native' || !outputFormat) return dt.toDate()
+  return dt.format(outputFormat)
+}
+
+export default sanitizeDate

package/{plugin-method → method}/sanitize/id.js

@@ -1,3 +1,13 @@
+/**
+ * Sanitize id according it's schema
+ *
+ * @method
+ * @memberof Dobo
+ * @param {(number|string)} id
+ * @param {Object} schema
+ * @returns {(number|string)}
+ */
+
 function sanitizeId (id, schema) {
   const prop = schema.properties.find(p => p.name === 'id')
   if (prop.type === 'integer') id = parseInt(id)