dobo 2.31.0 → 2.32.0

package/lib/factory/model/{_util.js → helper.js}

@@ -1,9 +1,23 @@
 import path from 'path'
 
-export const omittedOptionsKeys = ['req', 'reply', 'trx']
+/**
+ * Helper functions for model operations in the Dobo framework.
+ *
+ * @module Helper/Model
+ */
 
+/**
+ * Clone options object and omit some keys to avoid reference issues
+ *
+ * @method
+ * @name cloneOptions
+ * @memberof module:Helper/Model
+ * @param {DoboModel.TOptions} [options={}]
+ * @returns {DoboModel.TOptions} Cloned options object
+ */
 export function cloneOptions (options = {}) {
   const { cloneDeep, omit } = this.app.lib._
+  const omittedOptionsKeys = ['req', 'reply', 'trx']
   const nOptions = cloneDeep(omit(options, omittedOptionsKeys))
   for (const key of omittedOptionsKeys) {
     nOptions[key] = options[key]
@@ -11,6 +25,16 @@ export function cloneOptions (options = {}) {
   return nOptions
 }
 
+/**
+ * Executes a hook function with the provided name and arguments.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name execHook
+ * @param {string} name - The name of the hook to execute.
+ * @param  {...any} args - Arguments to pass to the hook function.
+ * @returns {Promise<void>}
+ */
 export async function execHook (name, ...args) {
   const { runHook } = this.app.bajo
   const { camelCase, last, kebabCase } = this.app.lib._
@@ -28,6 +52,16 @@ export async function execHook (name, ...args) {
   }
 }
 
+/**
+ * Executes a model hook function with the provided name and arguments.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name execModelHook
+ * @param {string} name - The name of the model hook to execute.
+ * @param  {...any} args - Arguments to pass to the model hook function.
+ * @returns {Promise<void>}
+ */
 export async function execModelHook (name, ...args) {
   const { last } = this.app.lib._
   const { runModelHook } = this.app.dobo
@@ -35,6 +69,16 @@ export async function execModelHook (name, ...args) {
   if (!noModelHook) await runModelHook(this, name, ...args)
 }
 
+/**
+ * Executes a dynamic hook function with the provided name and arguments.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name execDynHook
+ * @param {string} name - The name of the dynamic hook to execute.
+ * @param  {...any} args - Arguments to pass to the dynamic hook function.
+ * @returns {Promise<void>}
+ */
 export async function execDynHook (name, ...args) {
   const { last, orderBy } = this.app.lib._
   const opts = last(args)
@@ -49,6 +93,16 @@ export async function execDynHook (name, ...args) {
   return results
 }
 
+/**
+ * Executes validation on the provided body with the given options.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name execValidation
+ * @param {Object} body - The data to validate.
+ * @param {DoboModel.TOptions} [options={}] - Validation options.
+ * @returns {Promise<Object>} The result of the validation.
+ */
 export async function execValidation (body, options = {}) {
   const { uniq } = this.app.lib._
   const { validation = {} } = options
@@ -62,10 +116,15 @@ export async function execValidation (body, options = {}) {
 }
 
 /**
- * Break any reference to the original and get the new options
- *
- * @param {Object} options
- * @returns {Object}
+ * Prepares and returns the filter and options for a given action.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name getFilterAndOptions
+ * @param {DoboModel.TFilter} filter - The filter criteria.
+ * @param {DoboModel.TOptions} options - The options for the action.
+ * @param {string} action - The action being performed.
+ * @returns {Promise<{filter: DoboModel.TFilter, options: DoboModel.TOptions}>} The prepared filter and options.
  */
 export async function getFilterAndOptions (filter = {}, options = {}, action) {
   const { cloneDeep } = this.app.lib._
@@ -100,6 +159,17 @@ export async function getFilterAndOptions (filter = {}, options = {}, action) {
   return { filter: nFilter, options: nOptions }
 }
 
+/**
+ * Handles a request for a given action trigger.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name handleReq
+ * @param {string|number} id - The ID of the record.
+ * @param {string} trigger - The action trigger (e.g., 'created', 'updated', 'removed').
+ * @param {DoboModel.TOptions} [options={}] - Additional options for handling the request.
+ * @returns {Promise<void>}
+ */
 export async function handleReq (id, trigger, options = {}) {
   const { upperFirst } = this.app.lib._
   if (options.req) {
@@ -108,6 +178,17 @@ export async function handleReq (id, trigger, options = {}) {
   }
 }
 
+/**
+ * Merges attachment information into the given record.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name mergeAttachmentInfo
+ * @param {Object} rec - The record to merge attachment info into.
+ * @param {string} source - The source file path of the attachment.
+ * @param {Object} options - Additional options including mimeType, stats, and fullPath.
+ * @returns {Promise<void>}
+ */
 export async function mergeAttachmentInfo (rec, source, options = {}) {
   if (!this.app.waibu) return
   const { mimeType, stats, fullPath } = options
@@ -124,6 +205,18 @@ export async function mergeAttachmentInfo (rec, source, options = {}) {
   }
 }
 
+/**
+ * Gets the attachment path for a given record and field.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name getAttachmentPath
+ * @param {string|number} id - The ID of the record.
+ * @param {string} field - The field name of the attachment.
+ * @param {string} file - The file name of the attachment.
+ * @param {Object} options - Additional options, including dirOnly.
+ * @returns {Promise<string>} The path to the attachment.
+ */
 export async function getAttachmentPath (id, field, file, options = {}) {
   const { fs } = this.app.lib
   const dir = `${this.app.getPluginDataDir(this.app.dobo.ns)}/attachment/${this.name}/${id}`
@@ -133,6 +226,16 @@ export async function getAttachmentPath (id, field, file, options = {}) {
   return path
 }
 
+/**
+ * Copies attachments for a given record.
+ * @name copyAttachment
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @param {string|number} id - The ID of the record.
+ * @param {Object} options - Additional options for copying attachments.
+ * @returns {Promise<Array>} The copied attachment records.
+ */
 export async function copyAttachment (id, options = {}) {
   if (!this.app.waibu) return
   if (!this.options.attachment) return
@@ -157,6 +260,17 @@ export async function copyAttachment (id, options = {}) {
   return result
 }
 
+/**
+ * Handles attachment uploads for a given record and trigger.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name handleAttachmentUpload
+ * @param {string|number} id - The ID of the record.
+ * @param {string} trigger - The action trigger (e.g., 'added', 'removed').
+ * @param {Object} options - Additional options for handling the upload.
+ * @returns {Promise<void>}
+ */
 export async function handleAttachmentUpload (id, trigger, options = {}) {
   if (!this.options.attachment) return
   const { fs } = this.app.lib
@@ -169,6 +283,16 @@ export async function handleAttachmentUpload (id, trigger, options = {}) {
   return copyAttachment.call(this, id, { req, mimeType, stats, setFile, setField })
 }
 
+/**
+ * Gets reference records for the given records.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name getRefs
+ * @param {Array<Object>} records - The records to get references for.
+ * @param {Object} options - Additional options for fetching references.
+ * @returns {Promise<void>}
+ */
 export async function getRefs (records = [], options = {}) {
   const { isSet } = this.app.lib.aneka
   const { uniq, without, get } = this.app.lib._
@@ -224,12 +348,29 @@ export async function getRefs (records = [], options = {}) {
   }
 }
 
+/**
+ * Builds a sanitized filter query for the given filter.
+ * @memberof module:Helper/Model
+ * @method
+ * @name buildFilterQuery
+ * @param {Object} filter - The filter object containing query parameters.
+ * @returns {Object} The sanitized query object.
+ */
 export function buildFilterQuery (filter = {}) {
   const { parseQuery } = this.app.dobo
   const query = parseQuery(filter.query ?? {}, this, false)
   return sanitizeQuery.call(this, query)
 }
 
+/**
+ * Sanitizes a query object by ensuring that its fields and values conform to the model's schema.
+ * @memberof module:Helper/Model
+ * @method
+ * @name sanitizeQuery
+ * @param {Object} query - The query object to sanitize.
+ * @param {string} parent - The parent field name, if applicable.
+ * @returns {Object} The sanitized query object.
+ */
 export function sanitizeQuery (query = {}, parent) {
   const { isPlainObject, isArray, find, cloneDeep } = this.app.lib._
   const { isSet } = this.app.lib.aneka
@@ -277,6 +418,14 @@ export function sanitizeQuery (query = {}, parent) {
   return obj
 }
 
+/**
+ * Builds a search filter from the given filter object.
+ * @memberof module:Helper/Model
+ * @method
+ * @name buildFilterSearch
+ * @param {Object} filter - The filter object containing search parameters.
+ * @returns {Object} The constructed search filter.
+ */
 export function buildFilterSearch (filter = {}) {
   const { isPlainObject, trim, has, uniq } = this.app.lib._
   const search = filter.search ?? {}
@@ -315,8 +464,8 @@ export function buildFilterSearch (filter = {}) {
     }
   }
   if (has(items, '*')) s['*'] = items['*']
-  if (this.driver.idField.name !== 'id') {
-    const search = JSON.stringify(s).replaceAll('"id"', `"${this.driver.idField.name}"`)
+  if (this.adapter.idField.name !== 'id') {
+    const search = JSON.stringify(s).replaceAll('"id"', `"${this.adapter.idField.name}"`)
     try {
       s = JSON.parse(search)
     } catch (err) {}
@@ -325,17 +474,19 @@ export function buildFilterSearch (filter = {}) {
 }
 
 /**
- * Prepare records pagination:
- * - making sure records limit is obeyed
- * - making sure page is a positive value
- * - if skip is given, recalculate limit to use skip instead of page number
- * - Build sort info
+ * Prepare pagination parameters for a query:
+ * - Ensures that the limit does not exceed the maximum allowed limit.
+ * - Ensures that the page number is within the allowed range.
+ * - Calculates the number of records to skip based on the page and limit.
+ * - Builds the sort order based on the provided sort input.
  *
- * @method
  * @async
- * @param {Object} [filter={}] - Filter object
- * @param {Object} options - Options
- * @returns {TRecordPagination}
+ * @memberof module:Helper/Model
+ * @method
+ * @name preparePagination
+ * @param {DoboModel.TFilter} filter - The filter object containing pagination parameters.
+ * @param {DoboModel.TOptions} options - Additional options for pagination.
+ * @returns {Object} The prepared pagination parameters including limit, page, skip, and sort.
  */
 export function preparePagination (filter = {}, options = {}) {
   const { isEmpty, map, each, isPlainObject, isString, trim, keys } = this.app.lib._
@@ -406,6 +557,15 @@ export function preparePagination (filter = {}, options = {}) {
   return { limit, page, skip, sort }
 }
 
+/**
+ * Clears the cache for a specific record ID and related find operations.
+ * @async
+ * @memberof module:Helper/Model
+ * @method
+ * @name clearCache
+ * @param {string|number} id - The ID of the record for which to clear the cache.
+ * @returns {Promise<void>}
+ */
 export async function clearCache (id) {
   const { clear } = this.app.bajoCache ?? {}
   if (!clear) return

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

@@ -1,4 +1,4 @@
-import { getAttachmentPath } from './_util.js'
+import { getAttachmentPath } from './helper.js'
 import path from 'path'
 const action = 'removeAttachment'
 

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

@@ -1,35 +1,18 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs, handleReq, clearCache } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs, handleReq, clearCache } from './helper.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.
+ * Removes a record from the model's underlying data store based on the provided ID.
  *
- * Example:
- * ```javascript
- * const { recordRemove } = this.app.dobo
- * const result = await recordRemove('CdbCountry', 'ID')
- * ```
- *
- * @method
- * @memberof Model
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
  * @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
+ * @memberof DoboModel
+ * @method
+ * @param  {string|number} id - The ID of the record to be removed.
+ * @param  {DoboModel.TOptions} [opts={}] - Options object.
+ * @see {@link module:Hook.beforeRemoveRecord}
+ * @see {@link module:Hook.afterRemoveRecord}
+ * @returns {DoboAction|DoboModel.TResultRemoveRecord|DoboModel.TRecord}
  */
 async function removeRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
@@ -44,7 +27,7 @@ async function removeRecord (...args) {
   await execHook.call(this, 'beforeRemoveRecord', id, options)
   await execModelHook.call(this, 'beforeRemoveRecord', id, options)
   await execDynHook.call(this, 'beforeRemoveRecord', id, options)
-  const result = options.record ?? (await this.driver._removeRecord(this, id, options)) ?? {}
+  const result = options.record ?? (await this.adapter._removeRecord(this, id, options)) ?? {}
   if (noResult) return
   await handleReq.call(this, result.oldData.id, 'removed', options)
   await clearCache.call(this, id)

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

@@ -1,18 +1,20 @@
 /**
- * Sanitize payload body against its model
- *
+ * Sanitize the payload body based on the model's properties and rules.
  * @method
- * @memberof Dobo
+ * @memberof DoboModel
  * @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}
+ * @param {Object} [options={}] - Options object
+ * @param {Object} [options.body={}] - Body object to sanitize
+ * @param {boolean} [options.partial=false] - If `true`, only the fields present in the body will be sanitized
+ * @param {boolean} [options.strict=false] - If `true`, only the fields defined in the model's properties will be included in the sanitized body
+ * @param {Array} [options.extFields=[]] - Additional fields to include in the sanitized body
+ * @param {boolean} [options.truncateString=false] - If `true`, string fields will be truncated to their maximum length defined in the model's properties
+ * @param {string} [options.action] - The action being performed (e.g., 'createRecord', 'updateRecord', etc.)
+ * @param {boolean} [options.allProps=false] - If `true`, all properties including virtual ones will be considered for sanitization
+ * @returns {Object} Returns sanitized body object
  */
-async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDefault, truncateString, onlyTypes = [], action, allProps } = {}) {
+async function sanitizeBody (options = {}) {
+  const { body = {}, partial, strict, extFields = [], truncateString, action, allProps } = options
   const { isSet } = this.app.lib.aneka
   const { sanitizeByType } = this.app.dobo
   const { omit, has } = this.app.lib._
@@ -39,7 +41,7 @@ async function sanitizeBody ({ body = {}, partial, strict, extFields = [], noDef
       if (isSet(result[prop.name])) sanitize(prop.name, prop.type)
       if (result[prop.name] === null) continue
       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') && isSet(result[prop.name]) && prop.type === 'string' && ['smallint', 'integer'].includes(this.driver.idField.type)) result[prop.name] = result[prop.name] + ''
+      if (prop.name.endsWith('Id') && isSet(result[prop.name]) && prop.type === 'string' && ['smallint', 'integer'].includes(this.adapter.idField.type)) result[prop.name] = result[prop.name] + ''
       if (result[prop.name] === undefined) omitted.push(prop.name)
     } catch (err) {
       details.push({ field: prop.name, error: err.message, value: body[prop.name], ext: { type: prop.type } })

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

@@ -1,10 +1,23 @@
-async function sanitizeFixture ({ body = {}, lookupValue = {}, noLookup } = {}, options = {}) {
+/**
+ * Sanitize a fixture object by resolving lookup values and ensuring proper data types.
+ * @method
+ * @async
+ * @memberof DoboModel
+ * @param {Object} [params={}] - Parameters object
+ * @param {Object} [params.body={}] - Body object to sanitize
+ * @param {Object} [params.lookupValue={}] - Lookup values for resolving references in the body
+ * @param {boolean} [params.noLookup=false] - If `true`, skip lookup resolution
+ * @param {DoboModel.TOptions} [opts={}] - Options object for additional configurations
+ * @returns {Object} Returns sanitized body object
+ */
+async function sanitizeFixture (params = {}, opts = {}) {
+  const { body = {}, lookupValue = {}, noLookup } = params
   const { isString, isArray, pullAt, cloneDeep } = this.app.lib._
   const { isSet } = this.app.lib.aneka
   const lv = cloneDeep(lookupValue)
   const deleted = {}
-  const opts = {
-    ...options,
+  const options = {
+    ...opts,
     noModelHook: false,
     noHook: true,
     noDynHook: true,
@@ -16,7 +29,7 @@ async function sanitizeFixture ({ body = {}, lookupValue = {}, noLookup } = {},
     deleted[key] = deleted[key] ?? []
     if (!noLookup) {
       if (isString(val) && val.slice(0, 2) === '?:') {
-        body[key] = await this._simpleLookup(val.slice(2), lv, opts)
+        body[key] = await this._simpleLookup(val.slice(2), lv, options)
         lv[key] = body[key]
       } else if (isArray(val)) {
         for (const idx in val) {

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

@@ -1,13 +1,16 @@
 /**
- * Sanitize record to conform with the model's definition
- *
+ * Sanitize a record object based on the model's properties and rules.
  * @method
  * @async
+ * @memberof DoboModel
  * @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}
+ * @param {DoboModel.TOptions} [opts={}] - Options object
+ * @param {Array} [opts.fields] - If not empty, only these fields will be included in the sanitized record
+ * @param {Array<string>} [opts.hidden=[]] - List of fields to hide from the sanitized record
+ * @param {boolean} [opts.forceNoHidden=false] - If `true`, force ALL fields to be picked, thus ignoring hidden fields. If an array, force all fields except those in the array to be picked.
+ * @param {boolean} [opts.fmt=false] - If `true`, add a `_fmt` property to the sanitized record with formatted values automatically based on the model's properties and rules
+ * @param {Object} [opts.req] - Request object, used for formatting values based on request context
+ * @returns {Object} Returns sanitized record object
  */
 async function sanitizeRecord (record = {}, opts = {}) {
   const { fields = [], hidden = [], forceNoHidden } = opts

package/lib/factory/model/transaction.js

@@ -1,11 +1,11 @@
 async function transaction (handler, ...args) {
-  if (!this.driver.support.transaction) return handler.call(this)
+  if (!this.adapter.support.transaction) return handler.call(this)
 
   const { ns } = this.app.dobo
   const { camelCase } = this.app.lib._
   const { runHook } = this.app.bajo
   const name = 'afterTransaction'
-  const result = await this.driver.transaction(this, handler, ...args)
+  const result = await this.adapter.transaction(this, handler, ...args)
   const [action, ...params] = args
   await runHook(`${ns}:${name}`, this.name, action, result, ...params)
   await runHook(`${ns}.${camelCase(this.name)}:${name}`, action, result, ...params)

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

@@ -1,48 +1,20 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getRefs, handleReq, clearCache } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getRefs, handleReq, clearCache } from './helper.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
+ * Updates an existing record in the model's underlying data store based on the provided ID and data.
  *
- * 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
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
  * @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
+ * @memberof DoboModel
+ * @method
+ * @param  {string|number} id - The ID of the record to be updated.
+ * @param  {object} body - The data to update the record with.
+ * @param  {DoboModel.TOptions} [opts] - Options object.
+ * @see {@link module:Hook.beforeUpdateRecord}
+ * @see {@link module:Hook.afterUpdateRecord}
+ * @returns {DoboAction|DoboModel.TResultUpdateRecord|DoboModel.TRecord}
  */
 async function updateRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
@@ -66,7 +38,7 @@ async function updateRecord (...args) {
   await execModelHook.call(this, 'beforeUpdateRecord', id, input, options)
   await execDynHook.call(this, 'beforeUpdateRecord', id, input, options)
   if (!noValidation) await execValidation.call(this, input, options)
-  const result = await this.driver._updateRecord(this, id, input, options)
+  const result = await this.adapter._updateRecord(this, id, input, options)
   if (noResult) return
   await handleReq.call(this, result.data.id, 'updated', options)
   await clearCache.call(this, id)

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, execValidation, getRefs, handleReq, clearCache } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, execValidation, getRefs, handleReq, clearCache } from './helper.js'
 const action = 'upsertRecord'
 
 async function native (body = {}, opts = {}) {
@@ -15,7 +15,7 @@ async function native (body = {}, opts = {}) {
   await execHook.call(this, 'beforeUpsertRecord', input, options)
   await execModelHook.call(this, 'beforeUpsertRecord', input, options)
   await execDynHook.call(this, 'beforeUpsertRecord', input, options)
-  const result = options.record ?? (await this.driver._upsertRecord(this, input, options)) ?? {}
+  const result = options.record ?? (await this.adapter._upsertRecord(this, input, options)) ?? {}
   if (noResult) return
   await handleReq.call(this, result.data.id, 'upserted', options)
   await clearCache.call(this, body.id)
@@ -36,7 +36,7 @@ async function manual (body = {}, options = {}) {
   let old = false
   if (isSet(body.id)) {
     try {
-      old = await this.driver._getRecord(this, body.id, { noHook: true, noModelHook: true })
+      old = await this.adapter._getRecord(this, body.id, { noHook: true, noModelHook: true })
     } catch (err) {
     }
   }
@@ -46,51 +46,22 @@ async function manual (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
+ * Upserts a record in the model's underlying data store. If a record with the specified ID exists, it updates that record; otherwise, it creates a new record.
  *
- * 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
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
  * @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
+ * @memberof DoboModel
+ * @method
+ * @param  {object} body - The data for the record to be upserted.
+ * @param  {DoboModel.TOptions} [opts] - Options object.
+ * @see {@link module:Hook.beforeUpsertRecord}
+ * @see {@link module:Hook.afterUpsertRecord}
+ * @returns {DoboAction|DoboModel.TResultCreateRecord|DoboModel.TResultUpdateRecord|DoboModel.TRecord}
  */
 async function upsertRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
   const [body = {}, opts = {}] = args
-  if (this.driver.upsertRecord) {
+  if (this.adapter.upsertRecord) {
     const { options } = await getFilterAndOptions.call(this, null, opts, action)
     return await native.call(this, body, options)
   }