dobo 2.0.1 → 2.2.1

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

@@ -0,0 +1,56 @@
+/**
+ * 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, 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 (['string', 'text'].includes(type)) result[name] = sanitizeString(result[name], strict)
+    else if (['datetime'].includes(type)) result[name] = sanitizeDate(result[name], { input: 'native' })
+    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

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

@@ -0,0 +1,81 @@
+import { getFilterAndOptions, execHook, execValidation, execModelHook, getSingleRef, handleReq } from './_util.js'
+import { onlyTypes } from './create-record.js'
+const action = 'updateRecord'
+
+/**
+ * @typedef {Object} TRecordUpdateOptions
+ * @see Model#updateRecord
+ * @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} [noModelHook=false] - If ```true```, no model's 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} [noBodySanitizer=false] - If ```true```, accept data payload as is without sanitization
+ * @property {boolean} [noRecordSanitizer=false] - If ```true```, accept result 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 model's ```maxLength```
+ * @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 model
+ * @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 updateRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  let [id, body = {}, opts = {}] = args
+  const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
+  const { cloneDeep, get } = this.app.lib._
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  options.partial = options.partial ?? true
+  const { truncateString, noResult, noBodySanitizer, noResultSanitizer, noValidation, partial } = options
+  const extFields = get(options, 'validation.extFields', [])
+  id = this.sanitizeId(id)
+  const input = noBodySanitizer ? cloneDeep(body) : await this.sanitizeBody({ body, extFields, strict: true, truncateString, partial, onlyTypes })
+  delete input.id
+  await execHook.call(this, 'beforeUpdateRecord', id, input, options)
+  await execModelHook.call(this, 'beforeUpdateRecord', id, input, options)
+  if (!noValidation) await execValidation.call(this, input, options)
+  const result = options.record ?? (await this.driver._updateRecord(this, id, input, options)) ?? {}
+  if (noResult) {
+    await runHook('cache:clear', this, 'update', id, body)
+    return
+  }
+  if (!noResultSanitizer) {
+    result.data = await this.sanitizeRecord(result.data, options)
+    result.oldData = await this.sanitizeRecord(result.oldData, options)
+  }
+  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  await handleReq.call(this, result.data.id, 'updated', options)
+  await execModelHook.call(this, 'afterUpdateRecord', id, input, result, options)
+  await execHook.call(this, 'afterUpdateRecord', id, input, result, options)
+  await runHook('cache:clear', this, 'update', id, body, result)
+  return dataOnly ? result.data : result
+}
+
+export default updateRecord

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

@@ -0,0 +1,95 @@
+import { getFilterAndOptions, execHook, execModelHook, execValidation, getSingleRef, handleReq } from './_util.js'
+const action = 'upsertRecord'
+
+async function native (body = {}, opts = {}) {
+  const { isSet } = this.app.lib.aneka
+  const { runHook } = this.app.bajo
+  const { cloneDeep, get } = this.app.lib._
+  const { dataOnly = true } = opts
+  const { options } = await getFilterAndOptions.call(this, null, opts, action)
+  const { truncateString, noResult, noBodySanitizer, noResultSanitizer, noValidation } = options
+  const extFields = get(options, 'validation.extFields', [])
+  let input = noBodySanitizer ? cloneDeep(body) : await this.sanitizeBody({ body, extFields, strict: true, truncateString })
+  if (!noValidation) input = await execValidation.call(this, input, options)
+  await execHook.call(this, 'beforeUpsertRecord', input, options)
+  await execModelHook.call(this, 'beforeUpsertRecord', input, options)
+  const result = options.record ?? (await this.driver._upsertRecord(this, input, options)) ?? {}
+  if (noResult) {
+    await runHook('cache:clear', this, 'upsert', body)
+    return
+  }
+  if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
+  if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
+  await handleReq.call(this, result.data.id, 'upserted', options)
+  await execModelHook.call(this, 'afterUpsertRecord', input, result, options)
+  await execHook.call(this, 'afterUpsertRecord', input, result, options)
+  await runHook('cache:clear', this, 'upsert', body, result)
+  return dataOnly ? result.data : result
+}
+
+async function manual (body = {}, options = {}) {
+  const { isSet } = this.app.lib.aneka
+  if (isSet(body.id)) body.id = this.sanitizeId(body.id)
+  let old = false
+  if (isSet(body.id)) {
+    try {
+      old = await this.driver._getRecord(this, body.id, { noHook: true, noModelHook: true })
+    } catch (err) {}
+  }
+  if (old) return await this.updateRecord(old.data.id, body, options)
+  return await this.createRecord(body, options)
+}
+
+/**
+ * @typedef {Object} TRecordUpdateOptions
+ * @see Model#updateRecord
+ * @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} [noModelHook=false] - If ```true```, no model's 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} [noBodySanitizer=false] - If ```true```, accept data payload as is without sanitization
+ * @property {boolean} [noRecordSanitizer=false] - If ```true```, accept result 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 model's ```maxLength```
+ * @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 model
+ * @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 upsertRecord (...args) {
+  if (args.length === 0) return this.action(action, ...args)
+  const [body = {}, opts = {}] = args
+  if (this.driver.upsertRecord) {
+    const { options } = await getFilterAndOptions.call(this, null, opts, action)
+    return await native.call(this, body, options)
+  }
+  return await manual.call(this, body, opts)
+}
+
+export default upsertRecord

package/{method → lib/factory/model}/validate.js

@@ -89,14 +89,11 @@ const validator = {
   timestamp: ['timestamp']
 }
 
-function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } = {}) {
-  // if (schema.validation) return schema.validation
-  const {
-    isPlainObject, get, each, isEmpty, isString, forOwn, keys,
-    find, isArray, has, cloneDeep, concat, without
-  } = this.app.lib._
+function buildFromDbModel (opts = {}) {
+  const { isPlainObject, get, isEmpty, isString, keys, find, has, without } = this.app.lib._
+  const { fields = [], rule = {}, extFields = [] } = opts
   const obj = {}
-  const { propType } = this.app.pluginClass.dobo
+  const { propertyType: propType } = this.app.baseClass.Dobo
   const refs = []
 
   function getRuleKv (kvRule) {
@@ -116,36 +113,36 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } =
   function applyFieldRules (prop, obj) {
     const minMax = { min: false, max: false }
     const rules = get(rule, prop.name, prop.rules ?? [])
-    if (!isArray(rules)) return rules
-    each(rules, r => {
+    if (!Array.isArray(rules)) return rules
+    for (const r of rules) {
       const types = validator[propType[prop.type].validator]
       const { key, value } = getRuleKv(r)
       if (keys(minMax).includes(key)) minMax[key] = true
       if (key === 'ref') {
         refs.push(prop.name)
         obj = joi.ref(value)
-        return undefined
+        continue
       }
-      if (!key || !types.includes(key)) return undefined
+      if (!key || !types.includes(key)) continue
       obj = obj[key](value)
-    })
+    }
     if (refs.includes(prop.name)) return obj
     if (['string', 'text'].includes(prop.type)) {
-      forOwn(minMax, (v, k) => {
-        if (v) return undefined
+      for (const k in minMax) {
+        if (minMax[k]) continue
         if (has(prop, `${k}Length`)) obj = obj[k](prop[`${k}Length`])
-      })
+      }
     }
-    if (isArray(prop.values)) obj = obj.valid(...prop.values)
+    if (Array.isArray(prop.values)) obj = obj.valid(...prop.values)
     if (!['id'].includes(prop.name) && prop.required) obj = obj.required()
     return obj
   }
 
-  const props = concat(cloneDeep(schema.properties), extFields)
+  const props = [...this.properties, ...extFields]
 
   for (const p of props) {
     if (excludedTypes.includes(p.type) || excludedNames.includes(p.name)) continue
-    if (fields.length > 0 && !fields.includes(p.name)) continue
+    if (opts.partial && fields.length > 0 && !fields.includes(p.name)) continue
     let item
     switch (p.type) {
       case 'text':
@@ -175,38 +172,37 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } =
         break
     }
     if (item) {
-      if (item.$_root) obj[p.name] = item.allow(null)
+      if (item.$_root && !p.required) obj[p.name] = item.allow(null, '')
       else obj[p.name] = item
     }
   }
   if (isEmpty(obj)) return false
-  each(get(schema, 'globalRules', []), r => {
-    each(without(keys(obj), ...refs), k => {
+  for (const r of this.rules) {
+    for (const k of without(keys(obj), ...refs)) {
       const prop = find(props, { name: k })
-      if (!prop) return undefined
+      if (!prop) continue
       const types = validator[propType[prop.type].validator]
       const { key, value, columns = [] } = getRuleKv(r)
-      if (!types.includes(key)) return undefined
+      if (!types.includes(key)) continue
       if (columns.length === 0 || columns.includes(k)) obj[k] = obj[k][key](value)
-    })
-  })
+    }
+  }
   const result = joi.object(obj)
-  if (fields.length === 0) return result
-  each(['with', 'xor', 'without'], k => {
-    const item = get(schema, `extRule.${k}`)
+  for (const k of ['with', 'xor', 'without']) {
+    const item = get(this, `extRule.${k}`)
     if (item) result[k](...item)
-  })
+  }
   return result
 }
 
 /**
- * Validate value against JOI schema
+ * Validate value against JOI model
  *
  * @method
  * @memberof Dobo
  * @async
  * @param {Object} value - value to validate
- * @param {Object} joiSchema - JOI schema
+ * @param {Object} joiModel - JOI model
  * @param {Object} [options={}] - Options object
  * @param {string} [options.ns=dobo] - Scope's namespace
  * @param {Array} [options.fields=[]]
@@ -214,32 +210,22 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } =
  * @param {Object} [options.params={}] - Validation parameters. See {@tutorial config} and {@link https://joi.dev/api/?v=17.13.3#anyvalidateasyncvalue-options|JOI validate's options}
  * @returns {Object}
  */
-async function validate (value, joiSchema, { ns, fields, extFields, params } = {}) {
-  const { defaultsDeep, isSet } = this.app.lib.aneka
-  const { isString, forOwn, find } = this.app.lib._
+async function validate (body, joiModel, opts = {}) {
+  const { defaultsDeep } = this.app.lib.aneka
+  const { isEmpty } = this.app.lib._
+  let { fields, extFields = [], params = {}, partial } = opts
 
-  ns = ns ?? [this.ns]
-  params = defaultsDeep(params, this.config.validationParams)
+  params = defaultsDeep(params, this.app.dobo.config.validationParams)
   const { rule = {} } = params
   delete params.rule
-  if (isString(joiSchema)) {
-    const { schema } = this.getInfo(joiSchema)
-    forOwn(value, (v, k) => {
-      if (!isSet(v)) return undefined
-      const p = find(schema.properties, { name: k })
-      if (!p) return undefined
-      for (const t of ['date|YYYY-MM-DD', 'time|HH:mm:ss']) {
-        const [type, input] = t.split('|')
-        if (p.type === type) value[k] = this.sanitizeDate(value[k], { input, output: 'native' })
-      }
-    })
-    joiSchema = buildFromDbSchema.call(this, schema, { fields, rule, extFields })
-  }
-  if (!joiSchema) return value
+  if (isEmpty(joiModel)) joiModel = buildFromDbModel.call(this, { fields, rule, extFields, partial })
+  if (!joiModel) return { value: body }
   try {
-    return await joiSchema.validateAsync(value, params)
+    return await joiModel.validateAsync(body, params)
   } catch (err) {
-    throw this.error('validationError', { details: err.details, values: err.values, ns, statusCode: 422, code: 'DB_VALIDATION' })
+    const payload = { details: err.details, statusCode: 422, code: 'DB_VALIDATION' }
+    if (err.values) payload.values = err.values
+    throw this.plugin.error('validationError', payload)
   }
 }
 

package/lib/factory/model.js

@@ -0,0 +1,150 @@
+import { sanitizeAll, sanitizeRef } from '../collect-models.js'
+import clearRecord from './model/clear-record.js'
+import countRecord from './model/count-record.js'
+import createRecord from './model/create-record.js'
+import drop from './model/drop.js'
+import findAllRecord from './model/find-all-record.js'
+import findOneRecord from './model/find-one-record.js'
+import findRecord from './model/find-record.js'
+import getRecord from './model/get-record.js'
+import createHistogram from './model/create-histogram.js'
+import createAggregate from './model/create-aggregate.js'
+import exists from './model/exists.js'
+import build from './model/build.js'
+import loadFixtures from './model/load-fixtures.js'
+import removeRecord from './model/remove-record.js'
+import updateRecord from './model/update-record.js'
+import createAttachment from './model/create-attachment.js'
+import updateAttachment from './model/update-attachment.js'
+import getAttachment from './model/get-attachment.js'
+import removeAttachment from './model/remove-attachment.js'
+import findAttachment from './model/find-attachment.js'
+import sanitizeBody from './model/sanitize-body.js'
+import sanitizeRecord from './model/sanitize-record.js'
+import sanitizeId from './model/sanitize-id.js'
+import upsertRecord from './model/upsert-record.js'
+import listAttachment from './model/list-attachment.js'
+import validate from './model/validate.js'
+
+/**
+ * @typedef {string} TRecordSortKey
+ */
+
+/**
+ * Key value pairs used as sort information:
+ * - Key represent model's field name
+ * - value represent its sort order: ```1``` for ascending order, and ```-1``` for descending order
+ *
+ * Example: to sort by firstName (ascending) and lastName (descending)
+ * ```javascript
+ * const sort = {
+ *   firstName: 1,
+ *   lastName: -1
+ * }
+ * ```
+ *
+ * @typedef {Object.<string, TRecordSortKey>} TRecordSort
+ */
+
+/**
+ * @typedef {Object} TRecordPagination
+ * @property {number} limit - Number of records per page
+ * @property {number} page - Page number
+ * @property {number} skip - Records to skip
+ * @property {TRecordSort} sort - Sort order
+ */
+
+async function modelFactory () {
+  const { Tools } = this.app.baseClass
+  const { defaults } = this.app.lib._
+
+  /**
+   * Feature class
+   *
+   * ```this.plugin``` should be the one who owned this driver
+   *
+   * @class
+   */
+  class DoboModel extends Tools {
+    constructor (plugin, options) {
+      super(plugin)
+      defaults(this, options)
+      this.driver = this.connection.driver
+      this.cacheable = this.cacheable ?? this.driver.cacheable ?? true
+    }
+
+    action = (name, ...args) => {
+      const action = new this.app.baseClass.DoboAction(this, name, ...args)
+      return action
+    }
+
+    sanitizeObjectDef = async (obj) => {
+      await sanitizeAll.call(this.app.dobo, obj)
+    }
+
+    sanitizeRef = async (obj, fatal = true) => {
+      await sanitizeRef.call(this.app.dobo, obj, this.app.dobo.models, fatal)
+    }
+
+    getProperty = (name) => {
+      return this.properties.find(prop => prop.name === name)
+    }
+
+    hasProperty = (name) => {
+      return !!this.getProperty(name)
+    }
+
+    build = build
+    exists = exists
+    drop = drop
+
+    createRecord = createRecord
+    getRecord = getRecord
+    updateRecord = updateRecord
+    upsertRecord = upsertRecord
+    removeRecord = removeRecord
+    clearRecord = clearRecord
+    findRecord = findRecord
+    findOneRecord = findOneRecord
+    findAllRecord = findAllRecord
+
+    createAggregate = createAggregate
+    createHistogram = createHistogram
+    countRecord = countRecord
+
+    createAttachment = createAttachment
+    getAttachment = getAttachment
+    updateAttachment = updateAttachment
+    removeAttachment = removeAttachment
+    findAttachment = findAttachment
+    listAttachment = listAttachment
+
+    loadFixtures = loadFixtures
+    sanitizeRecord = sanitizeRecord
+    sanitizeBody = sanitizeBody
+    sanitizeId = sanitizeId
+    validate = validate
+
+    // aliases
+    deleteRecord = removeRecord
+    clearRecords = clearRecord
+    countRecords = countRecord
+    findRecords = findRecord
+    findAllRecords = findAllRecord
+    listAttachments = listAttachment
+
+    getField = (name) => this.getProperty(name)
+    hasField = (name) => this.hasProperty(name)
+
+    dispose () {
+      super.dispose()
+      this.connection = null
+      this.driver = null
+    }
+  }
+
+  this.app.baseClass.DoboModel = DoboModel
+  return DoboModel
+}
+
+export default modelFactory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dobo",
-  "version": "2.0.1",
+  "version": "2.2.1",
   "description": "DBMS for Bajo Framework",
   "main": "index.js",
   "scripts": {
@@ -9,7 +9,9 @@
   },
   "type": "module",
   "bajo": {
-    "type": "plugin"
+    "type": "plugin",
+    "alias": "db",
+    "bootorder": 50
   },
   "repository": {
     "type": "git",
@@ -31,8 +33,10 @@
   "homepage": "https://github.com/ardhi/dobo#readme",
   "dependencies": {
     "@tryghost/nql": "^0.12.7",
-    "joi": "^17.13.3",
-    "mingo": "^6.5.1"
+    "joi": "^18.0.2",
+    "mingo": "^7.1.0",
+    "ulid": "^3.0.2",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "clean-jsdoc-theme": "^4.3.0",