dobo 2.30.7 → 2.32.0

package/lib/factory/connection.js

@@ -1,9 +1,21 @@
+/**
+ * @typedef TOptions
+ * @memberof DoboConnection
+ * @property {string} [name='default'] - Connection name
+ * @property {string[]} models - List of model names to be used with this connection. Use this property to force models to be bound to this connection only.
+ */
+
+/**
+ * Connection factory
+ *
+ * @async
+ */
 async function connectionFactory () {
   const { Tools } = this.app.baseClass
   const { omit } = this.app.lib._
 
   /**
-   * Connection class
+   * Connection class definition.
    *
    * @class
    */
@@ -11,71 +23,83 @@ async function connectionFactory () {
     constructor (plugin, options = {}) {
       super(plugin)
       /**
-       * Driver object
-       *
+       * Adapter object
        * @type {Object}
        */
-      this.driver = undefined
+      this.adapter = undefined
 
       /**
        * Client instance
+       * @type {Object}
        */
       this.client = undefined
 
       /**
        * Connection name
-       *
        * @type {string}
        */
       this.name = options.name
+
+      /**
+       * Connection options
+       * @type {DoboConnection.TOptions}
+       */
       this.options = {
         models: []
       }
 
       /**
        * Options object from connection defined on ```dobo.config.connections```
-       *
        * @type {Object}
        */
-      if (options instanceof this.app.baseClass.DoboNullDriver) {
-        this.driver = options
-        this.options.connName = 'nulldriver'
+      if (options instanceof this.app.baseClass.DoboNullAdapter) {
+        this.adapter = options
+        this.options.connName = 'nulladapter'
       } else {
-        this.options = omit(options, ['name', 'driver'])
+        this.options = omit(options, ['name', 'adapter'])
         this.options.connName = options.name
         this.options.models = this.options.models ?? []
       }
     }
 
     /**
-     * Init driver. Called automatically during connections collection
-     *
-     * @param {strin} name - Driver name
+     * Initialize the adapter for this connection. If the adapter is already an instance of `DoboAdapter`,
+     * it will be used directly. Otherwise, it will be retrieved from the plugin's adapter registry
+     * and sanitized with the connection options.
+     * @param {string} name - Adapter name
      * @async
+     * @returns {Promise<void>}
      */
-    async initDriver (name) {
-      if (name instanceof this.app.baseClass.DoboDriver) this.driver = name
+    async initAdapter (name) {
+      if (name instanceof this.app.baseClass.DoboAdapter) this.adapter = name
       else {
-        this.driver = this.plugin.getDriver(name)
-        await this.driver.sanitizeConnection(this.options)
+        this.adapter = this.plugin.getAdapter(name)
+        await this.adapter.sanitizeConnection(this.options)
       }
     }
 
     /**
-     * Establish this connection through the driver to the actual database system. Driver developer must
-     * provide a method named ```connect()``` to connect the underlying database and (optionally) return its client instance.
+     * Establish this connection through the adapter to the actual database system. Adapter developer must
+     * provide a method named `connect()` to connect the underlying database and (optionally)
+     * return its client instance.
      *
-     * @param {boolean} [noRebuild] - If ```true```, the database table/collection won't be build automatically
+     * @param {boolean} [noRebuild] - If `true`, the database table/collection won't be build automatically
+     * @retyrns {Promise<void>}
      */
     async connect (noRebuild) {
-      const client = await this.driver.connect(this, noRebuild)
+      const client = await this.adapter.connect(this, noRebuild)
       if (client) this.client = client
       this.connected = true
     }
 
+    /**
+     * Dispose this connection
+     * @async
+     * @returns {Promise<void>}
+     */
     dispose = async () => {
       await super.dispose()
-      this.driver = null
+      this.adapter = null
     }
   }
 

package/lib/factory/feature.js

@@ -1,24 +1,44 @@
+/**
+ * Feature factory function.
+ *
+ * @async
+ * @returns {Promise<void>}
+ */
+
 async function featureFactory () {
   const { Tools } = this.app.baseClass
 
   /**
-   * Feature class
+   * Feature class definition.
    *
-   * ```this.plugin``` should be the one who owned this driver
+   * `this.plugin` should be the one who owned this adapter
    * @class
    */
   class DoboFeature extends Tools {
+    /**
+     * Constructor.
+     */
     constructor (plugin, options = {}) {
       super(plugin)
       /**
        * Feature name
-       *
        * @type {string}
        */
       this.name = options.name
+
+      /**
+       * Feature handler function.
+       * @type {Function}
+       */
       this.handler = options.handler
     }
 
+    /**
+     * Dispose the instance and clean up resources.
+     * @async
+     * @method
+     * @returns {Promise<void>}
+     */
     dispose = async () => {
       await super.dispose()
       this.name = null

package/lib/factory/model/build.js

@@ -1,13 +1,22 @@
-import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook } from './helper.js'
 const action = 'build'
 
+/**
+ * Build a model's definition based on its properties and rules.
+ *
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param {DoboModel.TOptions} opts - The options for building the model
+ * @returns {DoboModel.TResultRecord|DoboModel.TRecord}
+ */
 async function build (opts = {}) {
   opts.dataOnly = opts.dataOnly ?? true
   const { dataOnly } = opts
   const { options } = await getFilterAndOptions.call(this, null, opts, action)
   await execHook.call(this, 'beforeBuildModel', options)
   await execModelHook.call(this, 'beforeBuildModel', options)
-  const result = (await this.driver._buildModel(this, options)) ?? {}
+  const result = (await this.adapter._buildModel(this, options)) ?? {}
   await execModelHook.call(this, 'afterBuildModel', result, options)
   await execHook.call(this, 'afterBuildModel', result, options)
   return dataOnly ? result.data : result

package/lib/factory/model/bulk-create-record.js

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook } from './helper.js'
 
 export const onlyTypes = ['datetime', 'date', 'time', 'timestamp']
 const action = 'bulkCreateRecord'
@@ -26,7 +26,7 @@ async function bulkCreateRecord (...args) {
     }
   }
   // TODO: bulk don't return anything currently, it should return at least a stat
-  await this.driver._bulkCreateRecords(this, inputs, options)
+  await this.adapter._bulkCreateRecord(this, inputs, options)
   await execDynHook.call(this, 'afterBulkCreateRecord', inputs, options)
   await execModelHook.call(this, 'afterBulkCreateRecord', inputs, options)
   await execHook.call(this, 'afterBulkCreateRecord', inputs, options)

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

@@ -1,6 +1,16 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './helper.js'
 const action = 'clearRecord'
 
+/**
+ * Clears all records from the model's underlying data store.
+ *
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param  {DoboModel.TOptions} [opts={}] - Options object.
+ * @returns {DoboAction|DoboModel.TResultRecord|DoboModel.TRecord}
+ */
 async function clearRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
   const [opts = {}] = args
@@ -10,8 +20,8 @@ async function clearRecord (...args) {
   await execHook.call(this, 'beforeClearRecord', options)
   await execModelHook.call(this, 'beforeClearRecord', options)
   await execDynHook.call(this, 'beforeClearRecord', options)
-  const result = (await this.driver._clearRecord(this, options)) ?? {}
-  await execDynHook.call(this, 'beforeClearRecord', result, options)
+  const result = (await this.adapter._clearRecord(this, options)) ?? {}
+  await execDynHook.call(this, 'afterClearRecord', result, options)
   await execModelHook.call(this, 'afterClearRecord', result, options)
   await execHook.call(this, 'afterClearRecord', result, options)
   return dataOnly ? result.data : result

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

@@ -1,6 +1,17 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './helper.js'
 const action = 'countRecord'
 
+/**
+ * Counts the number of records in the model's underlying data store that match the provided filter criteria.
+ *
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param {DoboModel.TFilter} [filter={}] - The filter criteria to apply when counting records.
+ * @param {DoboModel.TOptions} [opts={}] - Options object.
+ * @returns {DoboAction|DoboModel.TResultRecord|DoboModel.TRecord}
+ */
 async function countRecord (...args) {
   const { getDefaultValues } = this.app.dobo
   if (args.length === 0) return this.action(action, ...args)
@@ -12,7 +23,7 @@ async function countRecord (...args) {
   await execHook.call(this, 'beforeCountRecord', filter, options)
   await execModelHook.call(this, 'beforeCountRecord', filter, options)
   await execDynHook.call(this, 'beforeCountRecord', filter, options)
-  const result = (await this.driver._countRecord(this, filter, options)) ?? {}
+  const result = (await this.adapter._countRecord(this, filter, options)) ?? {}
   if (result.data > hardCap) {
     result.warnings = result.warnings ?? []
     result.warnings.push(t('hardCapWarning%s%s', result.data, hardCap))

package/lib/factory/model/create-aggregate.js

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './helper.js'
 const action = 'createAggregate'
 
 async function createAggregate (...args) {
@@ -11,7 +11,7 @@ async function createAggregate (...args) {
   await execHook.call(this, 'beforeCreateAggregate', filter, params, options)
   await execModelHook.call(this, 'beforeCreateAggregate', filter, params, options)
   await execDynHook.call(this, 'beforeCreateAggregate', filter, params, options)
-  const result = (await this.driver._createAggregate(this, filter, params, options)) ?? {}
+  const result = (await this.adapter._createAggregate(this, filter, params, options)) ?? {}
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
   await execDynHook.call(this, 'afterCreateAggregate', filter, params, result, options)

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

@@ -1,4 +1,4 @@
-import { mergeAttachmentInfo, getAttachmentPath } from './_util.js'
+import { mergeAttachmentInfo, getAttachmentPath } from './helper.js'
 const action = 'createAttachment'
 
 async function createAttachment (...args) {

package/lib/factory/model/create-histogram.js

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './helper.js'
 const action = 'createHistogram'
 
 async function createHistogram (...args) {
@@ -11,7 +11,7 @@ async function createHistogram (...args) {
   await execHook.call(this, 'beforeCreateHistogram', filter, params, options)
   await execModelHook.call(this, 'beforeCreateHistogram', filter, params, options)
   await execDynHook.call(this, 'beforeCreateHistogram', filter, params, options)
-  const result = (await this.driver._createHistogram(this, filter, params, options)) ?? {}
+  const result = (await this.adapter._createHistogram(this, filter, params, options)) ?? {}
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
   await execDynHook.call(this, 'afterCreateHistogram', filter, params, result, options)

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

@@ -1,8 +1,21 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getRefs, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getRefs, handleReq } from './helper.js'
 
 export const onlyTypes = ['datetime', 'date', 'time', 'timestamp', 'array', 'object']
 const action = 'createRecord'
 
+/**
+ * Creates a new record in the model's underlying data store with the provided data.
+ *
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param  {object} body - The data for the new record to be created
+ * @param  {DoboModel.TOptions} [opts] - Options object
+ * @returns {DoboAction|DoboModel.TResultCreateRecord|DoboModel.TRecord}
+ * @see {@link module:Hook.beforeCreateRecord}
+ * @see {@link module:Hook.afterCreateRecord}
+ */
 async function createRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
   const [body = {}, opts = {}] = args
@@ -19,7 +32,7 @@ async function createRecord (...args) {
   await execModelHook.call(this, 'beforeCreateRecord', input, options)
   await execDynHook.call(this, 'beforeCreateRecord', input, options)
   if (!noValidation) await execValidation.call(this, input, options)
-  let result = options.record ?? (await this.driver._createRecord(this, input, options)) ?? {}
+  let result = options.record ?? (await this.adapter._createRecord(this, input, options)) ?? {}
   if (noResult) return
   await handleReq.call(this, result.data.id, 'created', options)
   result = result ?? {}

package/lib/factory/model/drop.js

@@ -1,13 +1,23 @@
-import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook } from './helper.js'
 const action = 'drop'
 
+/**
+ * Drops the model from the underlying data store.
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param  {DoboModel.TOptions} [opts] - Options object.
+ * @returns {DoboAction|DoboModel.TResult|boolean}
+ * @see {@link module:Hook.beforeDropModel}
+ * @see {@link module:Hook.afterDropModel}
+ */
 async function drop (opts = {}) {
   opts.dataOnly = opts.dataOnly ?? true
   const { dataOnly } = opts
   const { options } = await getFilterAndOptions.call(this, null, opts, action)
   await execHook.call(this, 'beforeDropModel', options)
   await execModelHook.call(this, 'beforeDropModel', options)
-  const result = (await this.driver._dropModel(this, options)) ?? {}
+  const result = (await this.adapter._dropModel(this, options)) ?? {}
   await execModelHook.call(this, 'afterDropModel', result, options)
   await execHook.call(this, 'afterModelDrop', result, options)
   return dataOnly ? result.data : result

package/lib/factory/model/exists.js

@@ -1,11 +1,15 @@
-import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook } from './helper.js'
 const action = 'modelExists'
 
 /**
- * Method to check if the underlaying table/collection exists already
- *
- * @param {Object} [options]
- * @returns {Object}
+ * Checks if the model exists in the underlying data store.
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param  {DoboModel.TOptions} [opts] - Options object.
+ * @returns {DoboAction|DoboModel.TResult|boolean}
+ * @see {@link module:Hook.beforeModelExists}
+ * @see {@link module:Hook.afterModelExists}
  */
 async function isExists (opts = {}) {
   opts.dataOnly = opts.dataOnly ?? true
@@ -13,7 +17,7 @@ async function isExists (opts = {}) {
   const { options } = await getFilterAndOptions.call(this, null, opts, action)
   await execHook.call(this, 'beforeModelExists', options)
   await execModelHook.call(this, 'beforeModelExists', options)
-  const result = (await this.driver._modelExists(this, options)) ?? {}
+  const result = (await this.adapter._modelExists(this, options)) ?? {}
   await execModelHook.call(this, 'afterModelExists', result, options)
   await execHook.call(this, 'afterModelExists', result, options)
   return dataOnly ? result.data : result

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

@@ -1,4 +1,4 @@
-import { getRefs, execHook, execModelHook, execDynHook, getFilterAndOptions, cloneOptions, sanitizeQuery } from './_util.js'
+import { getRefs, execHook, execModelHook, execDynHook, getFilterAndOptions, cloneOptions, sanitizeQuery } from './helper.js'
 const action = 'findAllRecord'
 
 async function native (...args) {
@@ -28,7 +28,7 @@ async function native (...args) {
       return dataOnly ? resp.data : resp
     }
   }
-  let result = options.record ?? (await this.driver._findAllRecord(this, filter, options)) ?? {}
+  let result = options.record ?? (await this.adapter._findAllRecord(this, filter, options)) ?? {}
   result.limit = filter.limit
   result.filter = pick(filter, ['query', 'match', 'sort'])
   result.warnings = result.warnings ?? []
@@ -89,10 +89,21 @@ async function loop (...args) {
   return dataOnly ? data : result
 }
 
+/**
+ * Finds all records from the model's underlying data store based on the provided filter.
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param  {DoboModel.TFilter} filter - The filter parameters for finding the records.
+ * @param  {DoboModel.TOptions} [opts] - Options object.
+ * @returns {DoboAction|DoboModel.TResultFindRecord|Array<DoboModel.TRecord>}
+ * @see {@link module:Hook.beforeFindAllRecord}
+ * @see {@link module:Hook.afterFindAllRecord}
+ */
 async function findAllRecord (...args) {
   // can't use action here, because people tends to use is without arguments
   // if (args.length === 0) return this.action(action, ...args)
-  if (this.driver.findAllRecord) {
+  if (this.adapter.findAllRecord) {
     return await native.call(this, ...args)
   }
   return await loop.call(this, ...args)

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

@@ -1,4 +1,4 @@
-import { mergeAttachmentInfo } from './_util.js'
+import { mergeAttachmentInfo } from './helper.js'
 const action = 'findAttachment'
 
 async function findAttachment (...args) {

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

@@ -1,7 +1,19 @@
-import { cloneOptions } from './_util.js'
+import { cloneOptions } from './helper.js'
 
 const action = 'findOneRecord'
 
+/**
+ * Finds a single record from the model's underlying data store based on the provided filter.
+ *
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
+ * @async
+ * @memberof DoboModel
+ * @method
+ * @param  {DoboModel.TFilter} filter - The filter parameters for finding the record.
+ * @param  {DoboModel.TOptions} [opts] - Options object.
+ * @returns {DoboAction|DoboModel.TResultFindRecord|Array<DoboModel.TRecord>}
+ * @see {@link module:Hook.beforeFindRecord}
+ */
 async function findOneRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
   const { getDefaultValues } = this.app.dobo

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

@@ -1,68 +1,32 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs, sanitizeQuery } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs, sanitizeQuery } from './helper.js'
 const action = 'findRecord'
 
 /**
- * @typedef {Object} TRecordFilter
+ * @typedef TFilter
+ * @type {Object}
+ * @memberof DoboModel
  * @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} limit - Maximum number of records to return
+ * @property {number} page - Which page to return
  * @property {number} skip - Records to skip
- * @property {TRecordSort} sort - Sort order info
+ * @property {DoboModel.TSort} 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
+ * Finds records in the model's underlying data store that match the provided filter criteria.
  *
- * 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
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
  * @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
+ * @memberof DoboModel
+ * @method
+ * @param {DoboModel.TFilter} [filter={}] - The filter criteria to apply when finding records.
+ * @param {DoboModel.TOptions} [opts={}] - Options object.
+ * @returns {DoboAction|DoboModel.TResultFindRecord|Array.<DoboModel.TRecord>}
+ * @see {@link module:Hook.beforeFindRecord}
+ * @see {@link module:Hook.afterFindRecord}
  */
 async function findRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
@@ -89,7 +53,7 @@ async function findRecord (...args) {
       return dataOnly ? resp.data : resp
     }
   }
-  let result = options.record ?? (await this.driver._findRecord(this, filter, options)) ?? {}
+  let result = options.record ?? (await this.adapter._findRecord(this, filter, options)) ?? {}
   result.page = filter.page
   result.limit = filter.limit
   result.filter = pick(filter, ['query', 'search', 'sort'])

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

@@ -1,46 +1,18 @@
-import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getRefs } from './helper.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 })
- * ```
+ * Gets a record from the model's underlying data store based on the provided ID.
  *
- * @method
- * @memberof Dobo
+ * If no arguments are provided, it automatically turns into a chainable {@link DoboAction} object.
  * @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
+ * @memberof DoboModel
+ * @method
+ * @param  {string|number} id - The ID of the record to be retrieved.
+ * @param  {DoboModel.TOptions} [opts] - Options object.
+ * @returns {DoboAction|DoboModel.TResultGetRecord|DoboModel.TRecord}
+ * @see {@link module:Hook.beforeGetRecord}
+ * @see {@link module:Hook.afterGetRecord}
  */
 async function getRecord (...args) {
   if (args.length === 0) return this.action(action, ...args)
@@ -64,7 +36,7 @@ async function getRecord (...args) {
       return dataOnly ? resp.data : resp
     }
   }
-  const result = options.record ?? (await this.driver._getRecord(this, id, options)) ?? {}
+  const result = options.record ?? (await this.adapter._getRecord(this, id, options)) ?? {}
   const { warnings } = getDefaultValues(options)
   if (!warnings) delete result.warnings
   if (isEmpty(result.data) && !options.throwNotFound) return dataOnly ? undefined : { data: undefined }