dobo 2.0.0 → 2.0.1

package/lib/exec-validation.js

@@ -1,10 +1,10 @@
 async function execValidation ({ name, body, options, partial }) {
   const { runHook } = this.app.bajo
-  const { keys, camelCase } = this.lib._
+  const { keys, camelCase } = this.app.lib._
   const { noHook } = options
   if (!noHook) {
-    await runHook(`${this.name}:beforeRecordValidation`, name, body, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordValidation`, body, options)
+    await runHook(`${this.ns}:beforeRecordValidation`, name, body, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordValidation`, body, options)
   }
   const { validation = {} } = options
   if (partial) {
@@ -12,8 +12,8 @@ async function execValidation ({ name, body, options, partial }) {
   }
   body = await this.validate(body, name, validation)
   if (!noHook) {
-    await runHook(`${this.name}:afterRecordValidation`, name, body, options)
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordValidation`, body, options)
+    await runHook(`${this.ns}:afterRecordValidation`, name, body, options)
+    await runHook(`${this.ns}.${camelCase(name)}:afterRecordValidation`, body, options)
   }
   return body
 }

package/lib/generic-prop-sanitizer.js

@@ -2,8 +2,9 @@ const indexTypes = ['default', 'unique', 'primary', 'fulltext']
 
 async function genericPropSanitizer ({ prop, schema, driver }) {
   const { join } = this.app.bajo
-  const { has, get, each } = this.lib._
-  const def = this.propType[prop.type]
+  const { has, get, each } = this.app.lib._
+  const { propType } = this.app.pluginClass.dobo
+  const def = propType[prop.type]
   // detect from drivers
   if (prop.type === 'string') {
     def.minLength = prop.minLength ?? 0
@@ -13,14 +14,14 @@ async function genericPropSanitizer ({ prop, schema, driver }) {
     if (def.minLength > 0) prop.required = true
   }
   if (prop.autoInc && !['smallint', 'integer'].includes(prop.type)) delete prop.autoInc
-  each(['minLength', 'maxLength', 'kind'], p => {
+  each(['minLength', 'maxLength', 'textType'], p => {
     if (!has(def, p)) {
       delete prop[p]
       return undefined
     }
     prop[p] = get(prop, p, get(this.config, `default.property.${prop.type}.${p}`, def[p]))
-    if (def.choices && !def.choices.includes(prop[p])) {
-      this.fatal('unsupportedAllowedChoices%s%s%s%s%s', p, prop[p], prop.name, schema.name, join(def.choices))
+    if (def.values && !def.values.includes(prop[p])) {
+      this.fatal('unsupportedAllowedChoices%s%s%s%s%s', p, prop[p], prop.name, schema.name, join(def.values))
     }
   })
   if (prop.index && !indexTypes.includes(prop.index.type)) {

package/lib/handle-attachment-upload.js

@@ -1,12 +1,12 @@
 async function handleAttachmentUpload ({ action, name, id, options = {} } = {}) {
   const { getPluginDataDir } = this.app.bajo
-  const { fs } = this.lib
+  const { fs } = this.app.lib
   const { req, mimeType, stats, setFile, setField } = options
 
   name = this.attachmentPreCheck(name)
   if (!name) return
   if (action === 'remove') {
-    const dir = `${getPluginDataDir(this.name)}/attachment/${name}/${id}`
+    const dir = `${getPluginDataDir(this.ns)}/attachment/${name}/${id}`
     await fs.remove(dir)
     return
   }

package/lib/index.js

@@ -0,0 +1,3 @@
+/**
+ * @module Lib
+ */

package/lib/mem-db/conn-sanitizer.js

@@ -1,5 +1,5 @@
 async function connSanitizer (connection) {
-  const { pick } = this.lib._
+  const { pick } = this.app.lib._
   const result = pick(connection, ['type', 'name', 'driver'])
   result.memory = true
   return result

package/lib/mem-db/instantiate.js

@@ -2,15 +2,15 @@ let saving = false
 
 async function instantiate ({ connection, schemas, noRebuild }) {
   const { getPluginDataDir } = this.app.bajo
-  const { fs } = this.lib
-  const { pick } = this.lib._
+  const { fs } = this.app.lib
+  const { pick } = this.app.lib._
   this.memDb = this.memDb ?? {}
   this.memDb.storage = this.memDb.storage ?? {}
   this.memDb.instances = this.memDb.instances ?? []
   const instance = pick(connection, ['name', 'type'])
   this.memDb.instances.push(instance)
   // if (noRebuild) return
-  const pdir = `${getPluginDataDir(this.name)}/memDb/data` // persistence dir
+  const pdir = `${getPluginDataDir(this.ns)}/memDb/data` // persistence dir
   fs.ensureDirSync(pdir)
   const persistence = []
   for (const schema of schemas) {
@@ -35,7 +35,7 @@ async function instantiate ({ connection, schemas, noRebuild }) {
       fs.writeFileSync(`${pdir}/${item}.json`, JSON.stringify(data), 'utf8')
     }
     saving = false
-  }, this.config.memDb.persistence.syncPeriod * 1000)
+  }, this.config.memDb.persistence.syncPeriodDur)
 }
 
 export default instantiate

package/lib/mem-db/method/record/find.js

@@ -2,7 +2,7 @@ import { Query } from 'mingo'
 
 async function find ({ schema, filter = {}, options = {} }) {
   const { prepPagination } = this.app.dobo
-  const { omit } = this.lib._
+  const { omit } = this.app.lib._
   const { limit, skip, sort, page } = await prepPagination(filter, schema)
   const criteria = filter.query ?? {}
   const q = new Query(criteria, { idKey: 'id' })

package/lib/mem-db/method/record/get.js

@@ -1,6 +1,6 @@
 async function get ({ schema, id, options = {} }) {
   const { thrownNotFound = true } = options
-  const { find } = this.lib._
+  const { find } = this.app.lib._
   const result = find(this.memDb.storage[schema.name], { id })
   if (!result && thrownNotFound) throw this.error('recordNotFound%s%s', id, schema.name, { statusCode: 404 })
   return { data: result }

package/lib/mem-db/method/record/remove.js

@@ -2,7 +2,7 @@ import getRecord from './get.js'
 
 async function remove ({ schema, id, options = {} }) {
   const { noResult } = options
-  const { findIndex, pullAt } = this.lib._
+  const { findIndex, pullAt } = this.app.lib._
   const rec = noResult ? undefined : await getRecord.call(this, { schema, id })
   const idx = findIndex(this.memDb.storage[schema.name], { id })
   pullAt(this.memDb.storage[schema.name], [idx])

package/lib/mem-db/method/record/update.js

@@ -2,7 +2,7 @@ import getRecord from './get.js'
 
 async function update ({ schema, id, body, options }) {
   const { noResult } = options
-  const { findIndex, merge } = this.lib._
+  const { findIndex, merge } = this.app.lib._
   const old = noResult ? undefined : await getRecord.call(this, { schema, id })
   const idx = findIndex(this.memDb.storage[schema.name], { id })
   const current = this.memDb.storage[schema.name][idx]

package/lib/mem-db/start.js

@@ -1,7 +1,7 @@
 import addFixtures from '../add-fixtures.js'
 
 async function start () {
-  const { filter, map } = this.lib._
+  const { filter, map } = this.app.lib._
 
   const conns = filter(this.connections, { type: 'dobo:memory' })
   const schemas = filter(this.schemas, s => {

package/lib/merge-attachment-info.js

@@ -1,7 +1,7 @@
 async function mergeAttachmentInfo (rec, source, { mimeType, stats, fullPath }) {
   const { importPkg } = this.app.bajo
-  const { fs } = this.lib
-  const { pick } = this.lib._
+  const { fs } = this.app.lib
+  const { pick } = this.app.lib._
   if (!this.app.waibu) return
   const mime = await importPkg('waibu:mime')
 

package/lib/multi-rel-rows.js

@@ -1,6 +1,6 @@
 async function multiRelRows ({ schema, records, options = {} }) {
-  const { isSet } = this.lib.aneka
-  const { uniq, find, map } = this.lib._
+  const { isSet } = this.app.lib.aneka
+  const { uniq, find, map } = this.app.lib._
   const props = schema.properties.filter(p => isSet(p.rel) && !(options.hidden ?? []).includes(p.name))
   // const props = schema.properties.filter(p => isSet(p.rel))
   options.rels = options.rels ?? []

package/lib/resolve-method.js

@@ -1,13 +1,13 @@
 async function resolveMethod (name, method, options = {}) {
   const { importModule } = this.app.bajo
-  const { fs } = this.lib
-  const { camelCase } = this.lib._
+  const { fs } = this.app.lib
+  const { camelCase } = this.app.lib._
   const { schema, driver, connection } = this.getInfo(name)
   const [group, action] = method.split('-')
   if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('methodIsDisabled%s%s', camelCase(method), name)
   let file
   if (connection.name === 'memory') file = `${this.app[driver.ns].dir.pkg}/lib/mem-db/method/${group}/${action}.js`
-  else file = `${this.app[driver.ns].dir.pkg}/extend/${this.name}/method/${group}/${action}.js`
+  else file = `${this.app[driver.ns].dir.pkg}/extend/${this.ns}/method/${group}/${action}.js`
   if (!fs.existsSync(file)) throw this.error('methodUnsupported%s%s', camelCase(method), name)
   const handler = await importModule(file)
   return { handler, schema, driver, connection }

package/lib/sanitize-schema.js

@@ -1,12 +1,12 @@
 import genericPropSanitizer from './generic-prop-sanitizer.js'
 
 async function sanitizeFeature (item) {
-  const { get, isPlainObject, mergeWith, isArray } = this.lib._
+  const { get, isPlainObject, mergeWith, isArray } = this.app.lib._
   for (const f of item.feature) {
     const feature = get(this.feature, f.name) // source from collectFeature
     if (!feature) this.fatal('unknownFeature%s%s', f.name, item.name)
     let [ns, path] = f.name.split('.')
-    if (!path) ns = this.name
+    if (!path) ns = this.ns
     const input = await feature.call(this.app[ns], f)
     let props = input.properties
     if (isPlainObject(props)) props = [props]
@@ -37,10 +37,11 @@ async function sanitizeFullText (item) {
 }
 
 async function sanitizeSchema (items) {
-  const { defaultsDeep } = this.lib.aneka
+  const { defaultsDeep } = this.app.lib.aneka
   const { freeze, fatal, importModule, join, breakNsPath, runHook } = this.app.bajo
-  const { isEmpty, orderBy, map, keys, findIndex, find, each, isString, get, isPlainObject, camelCase, uniq, filter } = this.lib._
-  const propTypes = keys(this.propType)
+  const { isEmpty, orderBy, map, keys, findIndex, find, each, isString, get, isPlainObject, camelCase, uniq, filter } = this.app.lib._
+  const { propType } = this.app.pluginClass.dobo
+  const propTypes = keys(propType)
   const schemas = []
   this.log.debug('loadingDbSchemas')
   for (const k in items) {
@@ -57,7 +58,7 @@ async function sanitizeSchema (items) {
       if (isEmpty(type)) type = conn.type
       const driver = find(this.drivers, { type, ns, driver: conn.driver })
       if (driver.lowerCaseModel) item.name = item.name.toLowerCase()
-      let file = `${ns}:/extend/${this.name}/lib/${type}/prop-sanitizer.js`
+      let file = `${ns}:/extend/${this.ns}/lib/${type}/prop-sanitizer.js`
       let propSanitizer = await importModule(file)
       if (!propSanitizer) propSanitizer = genericPropSanitizer
       for (const idx in item.properties) {
@@ -128,7 +129,7 @@ async function sanitizeSchema (items) {
         if (!all.includes(p.name)) all.push(p.name)
         else fatal.call(this, 'Field \'%s@%s\' should be used only once', p.name, item.name)
       })
-      file = `${ns}:/extend/${this.name}/lib/${type}/schema-sanitizer.js`
+      file = `${ns}:/extend/${this.ns}/lib/${type}/schema-sanitizer.js`
       const schemaSanitizer = await importModule(file)
       if (schemaSanitizer) await schemaSanitizer.call(this, { schema: item, connection: conn, driver })
       schemas.push(item)

package/lib/single-rel-rows.js

@@ -1,6 +1,6 @@
 async function singleRelRows ({ schema, record, options = {} }) {
-  const { isSet } = this.lib.aneka
-  const { find } = this.lib._
+  const { isSet } = this.app.lib.aneka
+  const { find } = this.app.lib._
   const props = schema.properties.filter(p => isSet(p.rel) && !(options.hidden ?? []).includes(p.name))
   const rels = {}
   options.rels = options.rels ?? []

package/method/attachment/copy-uploaded.js

@@ -1,12 +1,12 @@
 import path from 'path'
 
 async function copyUploaded (name, id, options = {}) {
-  const { fs } = this.lib
+  const { fs } = this.app.lib
   const { req, setField, setFile, mimeType, stats, silent = true } = options
   name = this.attachmentPreCheck(name)
   if (!name) {
     if (silent) return
-    throw this.error('isMissing%s', this.print.write('field.name'))
+    throw this.error('isMissing%s', this.t('field.name'))
   }
   if (!this.app.waibu) {
     if (silent) return

package/method/attachment/create.js

@@ -1,13 +1,13 @@
 import mergeAttachmentInfo from '../../lib/merge-attachment-info.js'
 
 async function create (name, id, options = {}) {
-  const { fs } = this.lib
-  const { isEmpty } = this.lib._
+  const { fs } = this.app.lib
+  const { isEmpty } = this.app.lib._
   name = this.attachmentPreCheck(name)
   if (!name) return
   const { source, field = 'file', file } = options
   if (isEmpty(file)) return
-  if (!source) throw this.error('isMissing%s', this.print.write('field.source'))
+  if (!source) throw this.error('isMissing%s', this.t('field.source'))
   const baseDir = await this.attachmentGetPath(name, id, field, file, { dirOnly: true })
   const { fullPath, stats, mimeType, req } = options
 

package/method/attachment/find.js

@@ -1,11 +1,11 @@
 import mergeAttachmentInfo from '../../lib/merge-attachment-info.js'
 
 async function find (name, id, options = {}) {
-  const { fastGlob, fs } = this.lib
+  const { fastGlob, fs } = this.app.lib
   const { getPluginDataDir } = this.app.bajo
   name = this.attachmentPreCheck(name)
   if (!name) return
-  const dir = `${getPluginDataDir(this.name)}/attachment/${name}/${id}`
+  const dir = `${getPluginDataDir(this.ns)}/attachment/${name}/${id}`
   if (!fs.existsSync(dir)) return []
   const files = await fastGlob(`${dir}/**/*`)
   const { fullPath, stats, mimeType } = options

package/method/attachment/get-path.js

@@ -1,8 +1,8 @@
 async function getPath (name, id, field, file, options = {}) {
   const { getPluginDataDir } = this.app.bajo
-  const { pascalCase } = this.lib.aneka
-  const { fs } = this.lib
-  const dir = `${getPluginDataDir(this.name)}/attachment/${pascalCase(name)}/${id}`
+  const { pascalCase } = this.app.lib.aneka
+  const { fs } = this.app.lib
+  const dir = `${getPluginDataDir(this.ns)}/attachment/${pascalCase(name)}/${id}`
   if (options.dirOnly) return dir
   const path = field ? `${dir}/${field}/${file}` : `${dir}/${file}`
   if (!fs.existsSync(path)) throw this.error('notFound')

package/method/attachment/get.js

@@ -1,7 +1,7 @@
 async function get (name, id, field, file, options = {}) {
   name = this.attachmentPreCheck(name)
   if (!name) return
-  const { find } = this.lib._
+  const { find } = this.app.lib._
   const all = await this.attachmentFind(name, id, options)
   if (field === 'null') field = null
   const data = find(all, { field, file })

package/method/attachment/pre-check.js

@@ -1,5 +1,5 @@
 function preCheck (name) {
-  const { pascalCase } = this.lib.aneka
+  const { pascalCase } = this.app.lib.aneka
   name = pascalCase(name)
   const schema = this.getSchema(name)
   if (!schema.attachment) return false

package/method/attachment/remove.js

@@ -1,5 +1,5 @@
 async function remove (name, id, field, file, options = {}) {
-  const { fs } = this.lib
+  const { fs } = this.app.lib
   name = this.attachmentPreCheck(name)
   if (!name) return
   const path = await this.attachmentGetPath(name, id, field, file)

package/method/bulk/create.js

@@ -3,10 +3,10 @@ import execValidation from '../../lib/exec-validation.js'
 import execFeatureHook from '../../lib/exec-feature-hook.js'
 
 async function create (name, inputs, options) {
-  const { isSet } = this.lib.aneka
+  const { isSet } = this.app.lib.aneka
   const { generateId, runHook } = this.app.bajo
   const { clearModel } = this.cache ?? {}
-  const { find } = this.lib._
+  const { find } = this.app.lib._
   options.dataOnly = options.dataOnly ?? true
   options.truncateString = options.truncateString ?? true
   const { noHook, noValidation } = options
@@ -20,8 +20,8 @@ async function create (name, inputs, options) {
     if (!noValidation) b = await execValidation.call(this, { noHook, name, b, options })
   }
   if (!noHook) {
-    await runHook(`${this.name}:beforeBulkCreate`, name, bodies, options)
-    await runHook(`${this.name}.${name}:beforeBulkCreate`, bodies, options)
+    await runHook(`${this.ns}:beforeBulkCreate`, name, bodies, options)
+    await runHook(`${this.ns}.${name}:beforeBulkCreate`, bodies, options)
   }
   for (const idx in bodies) {
     await execFeatureHook.call(this, 'beforeCreate', { schema, body: bodies[idx] })
@@ -37,8 +37,8 @@ async function create (name, inputs, options) {
     await execFeatureHook.call(this, 'afterCreate', { schema, body: bodies[idx] })
   }
   if (!noHook) {
-    await runHook(`${this.name}.${name}:afterBulkCreate`, bodies, options)
-    await runHook(`${this.name}:afterBulkCreate`, name, bodies, options)
+    await runHook(`${this.ns}.${name}:afterBulkCreate`, bodies, options)
+    await runHook(`${this.ns}:afterBulkCreate`, name, bodies, options)
   }
   if (clearModel) await clearModel({ model: name })
 }

package/method/model/clear.js

@@ -2,19 +2,19 @@ import resolveMethod from '../../lib/resolve-method.js'
 
 async function clear (name, options = {}) {
   const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
+  const { camelCase } = this.app.lib._
 
   await this.modelExists(name, true)
   const { noHook } = options
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-clear', options)
   if (!noHook) {
-    await runHook(`${this.name}:beforeModelClear`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelClear`, options)
+    await runHook(`${this.ns}:beforeModelClear`, schema, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeModelClear`, options)
   }
   const resp = await handler.call(this.app[driver.ns], { schema, options })
   if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelClear`, options, resp)
-    await runHook(`${this.name}:afterModelClear`, schema, options, resp)
+    await runHook(`${this.ns}.${camelCase(name)}:afterModelClear`, options, resp)
+    await runHook(`${this.ns}:afterModelClear`, schema, options, resp)
   }
   return resp
 }

package/method/model/create.js

@@ -1,18 +1,31 @@
 import resolveMethod from '../../lib/resolve-method.js'
 
+/**
+ * Create a new model:
+ * - read corresponding schema
+ * - attempt to create table/database/collection accordingly
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @instance
+ * @name modelCreate
+ * @param {string} name - Model's name
+ * @param {Object} [options={}] - Options object
+ */
 async function create (name, options = {}) {
   const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
+  const { camelCase } = this.app.lib._
 
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-create', options)
   if (!options.noHook) {
-    await runHook(`${this.name}:beforeModelCreate`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelCreate`, options)
+    await runHook(`${this.ns}:beforeModelCreate`, schema, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeModelCreate`, options)
   }
   await handler.call(this.app[driver.ns], { schema, options })
   if (!options.noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelCreate`, options)
-    await runHook(`${this.name}:afterModelCreate`, schema, options)
+    await runHook(`${this.ns}.${camelCase(name)}:afterModelCreate`, options)
+    await runHook(`${this.ns}:afterModelCreate`, schema, options)
   }
 }
 

package/method/model/drop.js

@@ -1,18 +1,30 @@
 import resolveMethod from '../../lib/resolve-method.js'
 
+/**
+ * Drop database model
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @instance
+ * @name modelDrop
+ * @param {string} name - Model's name
+ * @param {Object} [options={}] - Options object
+ */
+
 async function drop (name, options = {}) {
   const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
+  const { camelCase } = this.app.lib._
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-drop', options)
 
   if (!options.noHook) {
-    await runHook(`${this.name}:beforeModelDrop`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelDrop`, options)
+    await runHook(`${this.ns}:beforeModelDrop`, schema, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeModelDrop`, options)
   }
   await handler.call(this.app[driver.ns], { schema, options })
   if (!options.noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelDrop`, options)
-    await runHook(`${this.name}:afterModelDrop`, schema, options)
+    await runHook(`${this.ns}.${camelCase(name)}:afterModelDrop`, options)
+    await runHook(`${this.ns}:afterModelDrop`, schema, options)
   }
 }
 

package/method/model/exists.js

@@ -2,19 +2,32 @@ import resolveMethod from '../../lib/resolve-method.js'
 
 const cache = {}
 
+/**
+ * Check if model exists already
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @instance
+ * @name modelExists
+ * @param {string} name - Model's name
+ * @param {boolean} [thrown=false] - If ```true``` throw error if not exists instead of just silent
+ * @param {Object} [options={}] - Options object
+ * @returns {boolean}
+ */
 async function exists (name, thrown, options = {}) {
   if (cache[name]) return cache[name]
   const { runHook } = this.app.bajo
-  const { camelCase } = this.lib._
+  const { camelCase } = this.app.lib._
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-exists', options)
   if (!options.noHook) {
-    await runHook(`${this.name}:beforeModelExists`, schema, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeModelExists`, options)
+    await runHook(`${this.ns}:beforeModelExists`, schema, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeModelExists`, options)
   }
   const exist = await handler.call(this.app[driver.ns], { schema, options })
   if (!options.noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterModelExists`, exist, options)
-    await runHook(`${this.name}:afterModelExists`, schema, exist, options)
+    await runHook(`${this.ns}.${camelCase(name)}:afterModelExists`, exist, options)
+    await runHook(`${this.ns}:afterModelExists`, schema, exist, options)
   }
   if (!exist && thrown) throw this.error('modelNotExists%s', name)
   cache[name] = exist

package/method/record/clear.js

@@ -3,20 +3,20 @@ import resolveMethod from '../../lib/resolve-method.js'
 async function clear (name, opts = {}) {
   const { runHook } = this.app.bajo
   await this.modelExists(name, true)
-  const { cloneDeep, camelCase, omit } = this.lib._
+  const { cloneDeep, camelCase, omit } = this.app.lib._
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
   const { noHook } = options
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-clear', options)
   if (!noHook) {
-    await runHook(`${this.name}:beforeRecordClear`, name, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordClear`, options)
+    await runHook(`${this.ns}:beforeRecordClear`, name, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordClear`, options)
   }
   const resp = await handler.call(this.app[driver.ns], { schema, options })
   if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordClear`, options, resp)
-    await runHook(`${this.name}:afterRecordClear`, name, options, resp)
+    await runHook(`${this.ns}.${camelCase(name)}:afterRecordClear`, options, resp)
+    await runHook(`${this.ns}:afterRecordClear`, name, options, resp)
   }
   return resp
 }

package/method/record/count.js

@@ -1,10 +1,32 @@
 import resolveMethod from '../../lib/resolve-method.js'
 import execFeatureHook from '../../lib/exec-feature-hook.js'
 
+/**
+ * @typedef {Object} TRecordCountOptions
+ * @see Dobo#recordCount
+ * @property {boolean} [dataOnly=true] - If ```true``` (default) returns array of records. Otherwise {@link TFindRecordResult}
+ * @property {boolean} [noCache=true] - If ```true``` (default), result set won't be cached. This will overwrite model's ```cacheable``` property. Only applicable if {@link https://github.com/ardhi/bajo-cache|bajo-cache} is loaded
+ * @property {boolean} [noHook=false] - If ```true```, no model's hook will be executed
+ * @property {boolean} [noFeatureHook=false] - If ```true```, no model's feature hook will be executed
+ */
+
+/**
+ * Return the number of records found by given filter
+ *
+ * @method
+ * @memberof Dobo
+ * @async
+ * @instance
+ * @name recordCount
+ * @param {string} name - Model's name
+ * @param {TRecordFilter} [filter={}] - Filter object
+ * @param {TRecordCountOptions} [options={}]
+ * @returns {(TRecordCountResult|number)} Return ```number``` of records if ```options.dataOnly``` is set. {@link TRecordCountResult} otherwise
+ */
 async function count (name, filter = {}, opts = {}) {
   const { runHook } = this.app.bajo
   const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.lib._
+  const { cloneDeep, camelCase, omit } = this.app.lib._
   delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
@@ -19,8 +41,8 @@ async function count (name, filter = {}, opts = {}) {
   if (options.queryHandler) filter.query = await options.queryHandler.call(opts.req ? this.app[opts.req.ns] : this, filter.query, opts.req)
   filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
   if (!noHook) {
-    await runHook(`${this.name}:beforeRecordCount`, name, filter, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordCount`, filter, options)
+    await runHook(`${this.ns}:beforeRecordCount`, name, filter, options)
+    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordCount`, filter, options)
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'beforeCount', { schema, filter, options })
   if (get && !noCache && !options.record) {
@@ -33,8 +55,8 @@ async function count (name, filter = {}, opts = {}) {
   const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
   delete options.record
   if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordCount`, filter, options, record)
-    await runHook(`${this.name}:afterRecordCount`, name, filter, options, record)
+    await runHook(`${this.ns}.${camelCase(name)}:afterRecordCount`, filter, options, record)
+    await runHook(`${this.ns}:afterRecordCount`, name, filter, options, record)
   }
   if (set && !noCache) await set({ model: name, filter, options, record })
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterCount', { schema, filter, options, record })