dobo 2.0.0 → 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/lib/factory/model/find-record.js

@@ -0,0 +1,103 @@
+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.lib._
-  const { fs } = this.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.name, ignoreError: true })
-
-  if (isArray(overrides) && !isEmpty(overrides)) items = overrides
-  // extend
-  await eachPlugins(async function ({ dir }) {
-    const { name: 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.bajo.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

package/lib/factory/model/sanitize-body.js

@@ -0,0 +1,62 @@
+/**
+ * Sanitize payload body against its model
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @param {Object} [options={}]
+ * @param {Object} [options.body={}]
+ * @param {Object} [options.model={}]
+ * @param {boolean} [options.partial=false]
+ * @param {boolean} [options.strict=false]
+ * @param {Array} [options.extFields=[]]
+ * @returns {Object}
+ */
+async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDefault, truncateString, onlyTypes = [], action } = {}) {
+  const { isSet } = this.app.lib.aneka
+  const { callHandler } = this.app.bajo
+  const { omit, has, isString, isNaN } = this.app.lib._
+  const { sanitizeBoolean, sanitizeDate, sanitizeFloat, sanitizeTimestamp, sanitizeInt, sanitizeObject, sanitizeString } = this.app.dobo
+  const result = {}
+
+  const sanitize = (name, type) => {
+    if (onlyTypes.length > 0 && !onlyTypes.includes(type)) return
+    if (['object', 'array'].includes(type)) result[name] = sanitizeObject(result[name])
+    else if (type === 'boolean') result[name] = sanitizeBoolean(result[name])
+    else if (['float', 'double'].includes(type)) result[name] = sanitizeFloat(result[name], strict)
+    else if (['integer', 'smallint'].includes(type)) result[name] = sanitizeInt(result[name], strict)
+    else if (type === 'timestamp') result[name] = sanitizeTimestamp(result[name])
+    else if (['string', 'text'].includes(type)) result[name] = sanitizeString(result[name], strict)
+    else {
+      for (const t of ['datetime|native', 'date|YYYY-MM-DD', 'time|HH:mm:ss']) {
+        const [ptype, input] = t.split('|')
+        if (ptype === type) result[name] = sanitizeDate(result[name], { input })
+      }
+    }
+    if (!strict && isNaN(result[name])) result[name] = null
+    if (['updateRecord', 'upsertRecord'].includes(action) && type === 'string' && result[name] === '') result[name] = null
+  }
+
+  const omitted = []
+  for (const prop of [...this.properties, ...extFields]) {
+    if (partial && !has(body, prop.name)) continue
+    result[prop.name] = body[prop.name]
+    if (body[prop.name] === null) continue
+    if (isSet(body[prop.name])) sanitize(prop.name, prop.type)
+    else {
+      if (isSet(prop.default) && !noDefault) {
+        result[prop.name] = prop.default
+        if (isString(prop.default) && prop.default.startsWith('handler:')) {
+          const [, ...args] = prop.default.split(':')
+          if (args.length > 0) result[prop.name] = await callHandler(args.join(':'))
+        } else sanitize(prop.name, prop.type)
+      }
+    }
+    if (truncateString && isSet(result[prop.name]) && ['string', 'text'].includes(prop.type)) result[prop.name] = result[prop.name].slice(0, prop.maxLength)
+    if (prop.name.endsWith('Id') && prop.type === 'string' && ['smallint', 'integer'].includes(this.driver.idField.type)) result[prop.name] = result[prop.name] + ''
+    if (body[prop.name] === undefined) omitted.push(prop.name)
+  }
+  return omit(result, omitted)
+}
+
+export default sanitizeBody

package/lib/factory/model/sanitize-id.js

@@ -0,0 +1,7 @@
+function sanitizeId (id) {
+  const prop = this.properties.find(p => p.name === 'id')
+  if (prop.type === 'integer') id = parseInt(id)
+  return id
+}
+
+export default sanitizeId

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

@@ -0,0 +1,26 @@
+/**
+ * Sanitize record to conform with the model's definition
+ *
+ * @method
+ * @async
+ * @param {Object} [record] - Record object
+ * @param {Array} [options.fields] - Array of field names to be picked
+ * @param {Object} [options.hidden=[]] - Additional fields to be hidden in addition the one defined in model
+ * @param {boolean} [options.forceNoHidden] - Force ALL fields to be picked, thus ignoring hidden fields
+ * @returns {Object}
+ */
+async function sanitizeRecord (record = {}, opts = {}) {
+  const { fields = [], hidden = [], forceNoHidden } = opts
+  const { isEmpty, map, without } = this.app.lib._
+  const { fillObject } = this.app.lib.aneka
+  const allHidden = forceNoHidden ? [] : without([...this.hidden, ...hidden], 'id')
+  let newFields = [...fields]
+  if (isEmpty(newFields)) newFields = map(this.properties, prop => prop.name)
+  if (!newFields.includes('id')) newFields.unshift('id')
+  newFields = without(newFields, ...allHidden)
+  const newRecord = await this.sanitizeBody({ body: fillObject(record, newFields, null), noDefault: true })
+  if (record._ref) newRecord._ref = record._ref
+  return newRecord
+}
+
+export default sanitizeRecord

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

@@ -0,0 +1,9 @@
+const action = 'updateAttachment'
+
+async function updateAttachment (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [id, opts = {}] = args
+  return this.createAttachment(this, id, opts)
+}
+
+export default updateAttachment