dobo 1.0.2 → 1.0.3

package/bajo/.alias

@@ -0,0 +1 @@
+db

package/bajo/config.json

@@ -1,9 +1,13 @@
 {
-  "alias": "db",
   "connections": [],
   "dependencies": [],
   "mergeProps": ["connections"],
-  "defaults": {
+  "validationParams": {
+    "abortEarly": false,
+    "convert": false,
+    "allowUnknown": true
+  },
+  "default": {
     "property": {
       "text": {
         "kind": "text"
@@ -23,5 +27,11 @@
       "required": true,
       "index": { "type": "primary" }
     }
+  },
+  "memDb": {
+    "createDefConnAtStart": true,
+    "persistence": {
+      "syncPeriod": 1
+    }
   }
 }

package/bajo/init.js

@@ -3,13 +3,24 @@ import collectDrivers from '../lib/collect-drivers.js'
 import collectFeature from '../lib/collect-feature.js'
 import collectSchemas from '../lib/collect-schemas.js'
 
+async function checkType (item, items) {
+  const { filter } = this.app.bajo.lib._
+  const existing = filter(items, { type: 'dobo:memory' })
+  if (existing.length > 1) this.fatal('There could only be one connection type \'%s\'', item.type)
+}
+
 async function init () {
   const { buildCollections } = this.app.bajo
   const { fs } = this.app.bajo.lib
-  const cfg = this.config
-  fs.ensureDirSync(`${cfg.dir.data}/attachment`)
+  fs.ensureDirSync(`${this.dir.data}/attachment`)
   await collectDrivers.call(this)
-  this.connections = await buildCollections({ ns: this.name, handler: collectConnections, dupChecks: ['name'] })
+  if (this.config.memDb.createDefConnAtStart) {
+    this.config.connections.push({
+      type: 'dobo:memory',
+      name: 'memory'
+    })
+  }
+  this.connections = await buildCollections({ ns: this.name, container: 'connections', handler: collectConnections, dupChecks: ['name', checkType] })
   if (this.connections.length === 0) this.log.warn('No %s found!', this.print.write('connection'))
   await collectFeature.call(this)
   await collectSchemas.call(this)

package/bajo/method/attachment/create.js

@@ -20,7 +20,7 @@ async function create (name, id, options = {}) {
     file
   }
   await mergeAttachmentInfo.call(this, rec, dest, { mimeType, fullPath, stats })
-  if (req && req.flash) req.flash('dbsuccess', { message: req.i18n.t('File successfully uploaded') })
+  if (req && req.flash) req.flash('notify', req.t('Attachment successfully uploaded'))
   return rec
 }
 

package/bajo/method/attachment/get-path.js

@@ -4,7 +4,7 @@ async function getPath (name, id, field, file, options = {}) {
   const dir = `${getPluginDataDir(this.name)}/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')
+  if (!fs.existsSync(path)) throw this.error('notFound')
   return path
 }
 

package/bajo/method/attachment/get.js

@@ -5,7 +5,7 @@ async function get (name, id, field, file, options = {}) {
   const all = await this.attachmentFind(name, id, options)
   if (field === 'null') field = null
   const data = find(all, { field, file })
-  if (!data) throw this.error('notfound', { statusCode: 404 })
+  if (!data) throw this.error('notFound', { statusCode: 404 })
   return data
 }
 

package/bajo/method/attachment/remove.js

@@ -5,7 +5,7 @@ async function remove (name, id, field, file, options = {}) {
   const path = await this.attachmentGetPath(name, id, field, file)
   const { req } = options
   await fs.remove(path)
-  if (req && req.flash) req.flash('dbsuccess', { message: req.i18n.t('File successfully removed') })
+  if (req && req.flash) req.flash('notify', req.t('Attachment successfully removed'))
 }
 
 export default remove

package/bajo/method/build-query.js

@@ -4,6 +4,7 @@ async function buildQuery ({ filter, schema, options = {} } = {}) {
   const { trim, isString, isPlainObject } = this.app.bajo.lib._
   let query = {}
   if (isString(filter.query)) {
+    filter.oquery = filter.query
     if (trim(filter.query).startsWith('{')) query = JSON.parse(filter.query)
     else query = nql(filter.query).parse()
   } else if (isPlainObject(filter.query)) query = filter.query

package/bajo/method/bulk/create.js

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

package/bajo/method/get-connection.js

@@ -0,0 +1,6 @@
+function getConnection (name) {
+  const { find } = this.app.bajo.lib._
+  return find(this.connections, { name })
+}
+
+export default getConnection

package/bajo/method/get-info.js

@@ -2,8 +2,8 @@ function getInfo (name) {
   const { breakNsPath } = this.app.bajo
   const { find, map } = this.app.bajo.lib._
   const schema = this.getSchema(name)
-  const conn = find(this.connections, { name: schema.connection })
-  const [ns, type] = breakNsPath(conn.type)
+  const conn = this.getConnection(schema.connection)
+  const { ns, path: type } = breakNsPath(conn.type)
   const driver = find(this.drivers, { type, ns, driver: conn.driver })
   const instance = find(this.app[driver.ns].instances, { name: schema.connection })
   const opts = conn.type === 'mssql' ? { includeTriggerModifications: true } : undefined

package/bajo/method/get-schema.js

@@ -1,10 +1,10 @@
-function getSchema (input) {
+function getSchema (input, cloned = true) {
   const { find, isPlainObject, cloneDeep } = this.app.bajo.lib._
   let name = isPlainObject(input) ? input.name : input
   name = this.app.bajo.pascalCase(name)
   const schema = find(this.schemas, { name })
   if (!schema) throw this.error('Unknown model/schema \'%s\'', name)
-  return cloneDeep(schema)
+  return cloned ? cloneDeep(schema) : schema
 }
 
 export default getSchema

package/bajo/method/model/clear.js

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

package/bajo/method/model/create.js

@@ -2,10 +2,18 @@ import resolveMethod from '../../../lib/resolve-method.js'
 
 async function create (name, options = {}) {
   const { runHook } = this.app.bajo
+  const { camelCase } = this.app.bajo.lib._
+
   const { handler, schema } = await resolveMethod.call(this, name, 'model-create', options)
-  await runHook(`${this.name}:beforeCollCreate` + name, schema)
+  if (!options.noHook) {
+    await runHook(`${this.name}:beforeModelCreate`, schema, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeModelCreate`, options)
+  }
   await handler.call(this, { schema, options })
-  await runHook(`${this.name}:afterCollCreate` + name, schema)
+  if (!options.noHook) {
+    await runHook(`${this.name}.${camelCase(name)}:afterModelCreate`, options)
+    await runHook(`${this.name}:afterModelCreate`, schema, options)
+  }
 }
 
 export default create

package/bajo/method/model/drop.js

@@ -2,10 +2,18 @@ import resolveMethod from '../../../lib/resolve-method.js'
 
 async function drop (name, options = {}) {
   const { runHook } = this.app.bajo
+  const { camelCase } = this.app.bajo.lib._
   const { handler, schema } = await resolveMethod.call(this, name, 'model-drop', options)
-  await runHook(`${this.name}:beforeCollDrop` + name, schema)
+
+  if (!options.noHook) {
+    await runHook(`${this.name}:beforeModelDrop`, schema, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeModelDrop`, options)
+  }
   await handler.call(this, { schema, options })
-  await runHook(`${this.name}:afterCollDrop` + name, schema)
+  if (!options.noHook) {
+    await runHook(`${this.name}.${camelCase(name)}:afterModelDrop`, options)
+    await runHook(`${this.name}:afterModelDrop`, schema, options)
+  }
 }
 
 export default drop

package/bajo/method/model/exists.js

@@ -5,10 +5,17 @@ const cache = {}
 async function exists (name, thrown, options = {}) {
   if (cache[name]) return cache[name]
   const { runHook } = this.app.bajo
+  const { camelCase } = this.app.bajo.lib._
   const { handler, schema } = await resolveMethod.call(this, name, 'model-exists', options)
-  await runHook(`${this.name}:beforeCollExists` + name, schema)
+  if (!options.noHook) {
+    await runHook(`${this.name}:beforeModelExists`, schema, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeModelExists`, options)
+  }
   const exist = await handler.call(this, { schema, options })
-  await runHook(`${this.name}:afterCollExists` + name, schema, exist)
+  if (!options.noHook) {
+    await runHook(`${this.name}.${camelCase(name)}:afterModelExists`, exist, options)
+    await runHook(`${this.name}:afterModelExists`, schema, exist, options)
+  }
   if (!exist && thrown) throw this.error('Model doesn\'t exist yet. Please do model rebuild first')
   cache[name] = exist
   return exist

package/bajo/method/pick-record.js

@@ -1,30 +1,36 @@
-async function transform ({ record, schema, hidden = [] } = {}) {
-  const { dayjs } = this.app.bajo
+async function transform ({ record, schema, hidden = [], forceNoHidden } = {}) {
+  const { dayjs } = this.app.bajo.lib
   if (record._id) {
     record.id = record._id
     delete record._id
   }
-  const result = {}
+  const defHidden = [...schema.hidden, ...hidden]
+  let result = {}
   for (const p of schema.properties) {
-    if (hidden.includes(p.name)) continue
+    if (!forceNoHidden && defHidden.includes(p.name)) continue
     result[p.name] = record[p.name] ?? null
     if (record[p.name] === null) continue
     switch (p.type) {
+      case 'boolean': result[p.name] = !!result[p.name]; break
       case 'time': result[p.name] = dayjs(record[p.name]).format('HH:mm:ss'); break
       case 'date': result[p.name] = dayjs(record[p.name]).format('YYYY-MM-DD'); break
+      case 'datetime': result[p.name] = dayjs(record[p.name]).toISOString(); break
     }
   }
-  return await this.sanitizeBody({ body: result, schema, partial: true, ignoreNull: true })
+  result = await this.sanitizeBody({ body: result, schema, partial: true, ignoreNull: true })
+  if (record._rel) result._rel = record._rel
+  return result
 }
 
-async function pickRecord ({ record, fields, schema = {}, hidden = [] } = {}) {
+async function pickRecord ({ record, fields, schema = {}, hidden = [], forceNoHidden } = {}) {
   const { isArray, pick, clone, isEmpty, omit } = this.app.bajo.lib._
   if (isEmpty(record)) return record
   if (hidden.length > 0) record = omit(record, hidden)
-  if (!isArray(fields)) return await transform.call(this, { record, schema, hidden })
+  if (!isArray(fields)) return await transform.call(this, { record, schema, hidden, forceNoHidden })
   const fl = clone(fields)
   if (!fl.includes('id')) fl.unshift('id')
-  return pick(await transform.call(this, { record, schema, hidden }), fl)
+  if (record._rel) fl.push('_rel')
+  return pick(await transform.call(this, { record, schema, hidden, forceNoHidden }), fl)
 }
 
 export default pickRecord

package/bajo/method/prep-pagination.js

@@ -1,6 +1,6 @@
 function buildPageSkipLimit (filter) {
-  let limit = parseInt(filter.limit) || this.config.defaults.filter.limit
-  if (limit > this.config.defaults.filter.maxLimit) limit = this.config.defaults.filter.maxLimit
+  let limit = parseInt(filter.limit) || this.config.default.filter.limit
+  if (limit > this.config.default.filter.maxLimit) limit = this.config.default.filter.maxLimit
   if (limit < 1) limit = 1
   let page = parseInt(filter.page) || 1
   if (page < 1) page = 1
@@ -14,11 +14,11 @@ function buildPageSkipLimit (filter) {
 }
 
 function buildSort (input, schema, allowSortUnindexed) {
-  const { isEmpty, map, each, isPlainObject, isString, trim, filter, keys } = this.app.bajo.lib._
+  const { isEmpty, map, each, isPlainObject, isString, trim, keys } = this.app.bajo.lib._
   let sort
   if (schema && isEmpty(input)) {
     const columns = map(schema.properties, 'name')
-    each(this.config.defaults.filter.sort, s => {
+    each(this.config.default.filter.sort, s => {
       const [col] = s.split(':')
       if (columns.includes(col)) {
         input = s
@@ -39,13 +39,9 @@ function buildSort (input, schema, allowSortUnindexed) {
       sort = item
     }
     if (schema) {
-      const indexes = map(filter(schema.properties, p => !!p.index), 'name')
-      each(schema.indexes, item => {
-        indexes.push(...item.fields)
-      })
       const items = keys(sort)
       each(items, i => {
-        if (!indexes.includes(i) && !allowSortUnindexed) throw this.error('Sort on unindexed field: \'%s@%s\'', i, schema.name)
+        if (!schema.sortables.includes(i) && !allowSortUnindexed) throw this.error('Sort on unindexed field: \'%s@%s\'', i, schema.name)
         // if (schema.fullText.fields.includes(i)) throw this.error('Can\'t sort on full-text index: \'%s@%s\'', i, schema.name)
       })
     }

package/bajo/method/record/clear.js

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

package/bajo/method/record/create.js

@@ -6,55 +6,53 @@ import execFeatureHook from '../../../lib/exec-feature-hook.js'
 
 async function create (name, input, opts = {}) {
   const { generateId, runHook, isSet } = this.app.bajo
-  const { clearColl } = this.cache ?? {}
-  const { get, find, forOwn, cloneDeep } = this.app.bajo.lib._
-  const options = cloneDeep(opts)
+  const { clearModel } = this.cache ?? {}
+  const { find, forOwn, cloneDeep, camelCase, omit, get } = this.app.bajo.lib._
+  const options = cloneDeep(omit(opts, ['req']))
+  options.req = opts.req
   options.dataOnly = options.dataOnly ?? true
   input = cloneDeep(input)
-  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, hidden } = options
+  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, hidden, forceNoHidden } = options
   options.truncateString = options.truncateString ?? true
   options.dataOnly = false
   await this.modelExists(name, true)
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-create', options)
   const idField = find(schema.properties, { name: 'id' })
+  const extFields = get(options, 'validation.extFields', [])
   if (!isSet(input.id)) {
     if (idField.type === 'string') input.id = generateId()
     else if (['integer', 'smallint'].includes(idField.type) && !idField.autoInc) input.id = generateId('int')
   }
-  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, strict: true })
+  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, extFields, strict: true })
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeRecordCreate`, name, body, options)
-    await runHook(`${this.name}.${name}:onBeforeRecordCreate`, body, options)
+    await runHook(`${this.name}:beforeRecordCreate`, name, body, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeRecordCreate`, body, options)
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'beforeCreate', { schema, body })
-  if (!noValidation) body = await execValidation.call(this, { noHook, name, body, options })
+  if (!noValidation) body = await execValidation.call(this, { name, body, options })
   if (isSet(body.id) && !noCheckUnique) await checkUnique.call(this, { schema, body })
   let record = {}
-  try {
-    const nbody = {}
-    forOwn(body, (v, k) => {
-      if (v === undefined) return undefined
-      const prop = find(schema.properties, { name: k })
-      if (options.truncateString && isSet(v) && prop && ['string', 'text'].includes(prop.type)) v = v.slice(0, prop.maxLength)
-      nbody[k] = v
-    })
-    record = await handler.call(this.app[driver.ns], { schema, body: nbody, options })
-    if (options.req) {
-      if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id: body.id, body, options, action: 'create' })
-      if (options.req.flash) options.req.flash('dbsuccess', { message: this.print.write('Record successfully created'), record })
-    }
-  } catch (err) {
-    if (get(options, 'req.flash')) options.req.flash('dberr', err)
-    throw err
+  const nbody = {}
+  forOwn(body, (v, k) => {
+    if (v === undefined) return undefined
+    const prop = find(schema.properties, { name: k })
+    if (!prop) return undefined
+    if (options.truncateString && isSet(v) && ['string', 'text'].includes(prop.type)) v = v.slice(0, prop.maxLength)
+    nbody[k] = v
+  })
+  record = await handler.call(this.app[driver.ns], { schema, body: nbody, options })
+  if (options.req) {
+    if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id: body.id, body, options, action: 'create' })
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('Record successfully created'))
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterCreate', { schema, body, record })
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterRecordCreate`, body, options, record)
-    await runHook(`${this.name}:onAfterRecordCreate`, name, body, options, record)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordCreate`, body, options, record)
+    await runHook(`${this.name}:afterRecordCreate`, name, body, options, record)
   }
-  if (clearColl) await clearColl({ model: name, body, options, record })
+  if (clearModel) await clearModel({ model: name, body, options, record })
   if (noResult) return
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden })
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   return dataOnly ? record.data : record
 }
 

package/bajo/method/record/find-one.js

@@ -4,18 +4,19 @@ import singleRelRows from '../../../lib/single-rel-rows.js'
 async function findOne (name, filter = {}, opts = {}) {
   const { runHook, isSet } = this.app.bajo
   const { get, set } = this.cache ?? {}
-  const { cloneDeep } = this.app.bajo.lib._
-  const options = cloneDeep(opts)
+  const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  const options = cloneDeep(omit(opts, ['req']))
+  options.req = opts.req
   options.dataOnly = options.dataOnly ?? true
-  const { fields, dataOnly, noHook, noCache, hidden } = options
+  const { fields, dataOnly, noHook, noCache, hidden, forceNoHidden } = options
   await this.modelExists(name, true)
   filter.limit = 1
   options.count = false
   options.dataOnly = false
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-find')
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-find', options)
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeRecordFindOne`, name, filter, options)
-    await runHook(`${this.name}.${name}:onBeforeRecordFindOne`, filter, options)
+    await runHook(`${this.name}:beforeRecordFindOne`, name, filter, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeRecordFindOne`, filter, options)
   }
   if (get && !noCache) {
     const cachedResult = await get({ model: name, filter, options })
@@ -27,10 +28,10 @@ async function findOne (name, filter = {}, opts = {}) {
   const record = await handler.call(this.app[driver.ns], { schema, filter, options })
   record.data = record.data[0]
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterRecordFindOne`, filter, options, record)
-    await runHook(`${this.name}:onAfterRecordFindOne`, name, filter, options, record)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordFindOne`, filter, options, record)
+    await runHook(`${this.name}:afterRecordFindOne`, name, filter, options, record)
   }
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden })
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
   if (set && !noCache) await set({ model: name, filter, options, record })
   return dataOnly ? record.data : record

package/bajo/method/record/find.js

@@ -4,19 +4,21 @@ import multiRelRows from '../../../lib/multi-rel-rows.js'
 async function find (name, filter = {}, opts = {}) {
   const { runHook, isSet } = this.app.bajo
   const { get, set } = this.cache ?? {}
-  const { cloneDeep } = this.app.bajo.lib._
-  const options = cloneDeep(opts)
+  const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  const options = cloneDeep(omit(opts, ['req']))
+  options.req = opts.req
   options.dataOnly = options.dataOnly ?? true
-  const { fields, dataOnly, noHook, noCache, hidden } = options
+  const { fields, dataOnly, noHook, noCache, hidden, forceNoHidden } = options
   options.count = options.count ?? false
   options.dataOnly = false
   await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-find')
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-find', options)
   filter.query = await this.buildQuery({ filter, schema, options }) ?? {}
+  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}:onBeforeRecordFind`, name, filter, options)
-    await runHook(`${this.name}.${name}:onBeforeRecordFind`, filter, options)
+    await runHook(`${this.name}:beforeRecordFind`, name, filter, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeRecordFind`, filter, options)
   }
   if (get && !noCache) {
     const cachedResult = await get({ model: name, filter, options })
@@ -27,11 +29,11 @@ async function find (name, filter = {}, opts = {}) {
   }
   const records = await handler.call(this.app[driver.ns], { schema, filter, options })
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterRecordFind`, filter, options, records)
-    await runHook(`${this.name}:onAfterRecordFind`, name, filter, options, records)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordFind`, filter, options, records)
+    await runHook(`${this.name}:afterRecordFind`, name, filter, options, records)
   }
   for (const idx in records.data) {
-    records.data[idx] = await this.pickRecord({ record: records.data[idx], fields, schema, hidden })
+    records.data[idx] = await this.pickRecord({ record: records.data[idx], fields, schema, hidden, forceNoHidden })
   }
   if (isSet(options.rels)) await multiRelRows.call(this, { schema, records: records.data, options })
   if (set && !noCache) await set({ model: name, filter, options, records })

package/bajo/method/record/get.js

@@ -4,17 +4,18 @@ import singleRelRows from '../../../lib/single-rel-rows.js'
 async function get (name, id, opts = {}) {
   const { runHook, isSet } = this.app.bajo
   const { get, set } = this.cache ?? {}
-  const { cloneDeep } = this.app.bajo.lib._
-  const options = cloneDeep(opts)
+  const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  const options = cloneDeep(omit(opts, ['req']))
+  options.req = opts.req
   options.dataOnly = options.dataOnly ?? true
-  const { fields, dataOnly, noHook, noCache, hidden = [] } = options
+  const { fields, dataOnly, noHook, noCache, hidden = [], forceNoHidden } = options
   await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-get')
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-get', options)
   id = this.sanitizeId(id, schema)
   options.dataOnly = false
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeRecordGet`, name, id, options)
-    await runHook(`${this.name}.${name}:onBeforeRecordGet`, id, options)
+    await runHook(`${this.name}:beforeRecordGet`, name, id, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeRecordGet`, id, options)
   }
   if (get && !noCache) {
     const cachedResult = await get({ model: name, id, options })
@@ -25,10 +26,10 @@ async function get (name, id, opts = {}) {
   }
   const record = await handler.call(this.app[driver.ns], { schema, id, options })
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterRecordGet`, id, options, record)
-    await runHook(`${this.name}:onAfterRecordGet`, name, id, options, record)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordGet`, id, options, record)
+    await runHook(`${this.name}:afterRecordGet`, name, id, options, record)
   }
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden })
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
 
   if (set && !noCache) await set({ model: name, id, options, record })

package/bajo/method/record/remove.js

@@ -3,31 +3,32 @@ import handleAttachmentUpload from '../../../lib/handle-attachment-upload.js'
 
 async function remove (name, id, opts = {}) {
   const { runHook } = this.app.bajo
-  const { clearColl } = this.cache ?? {}
-  const { cloneDeep } = this.app.bajo.lib._
-  const options = cloneDeep(opts)
+  const { clearModel } = this.cache ?? {}
+  const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  const options = cloneDeep(omit(opts, ['req']))
+  options.req = opts.req
   options.dataOnly = options.dataOnly ?? true
-  const { fields, dataOnly, noHook, noResult, hidden } = options
+  const { fields, dataOnly, noHook, noResult, hidden, forceNoHidden } = options
   options.dataOnly = false
   await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-remove')
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-remove', options)
   id = this.sanitizeId(id, schema)
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeRecordRemove`, name, id, options)
-    await runHook(`${this.name}.${name}:onBeforeRecordRemove`, id, options)
+    await runHook(`${this.name}:beforeRecordRemove`, name, id, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeRecordRemove`, id, options)
   }
   const record = await handler.call(this.app[driver.ns], { schema, id, options })
   if (options.req) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, options, action: 'remove' })
-    if (options.req.flash) options.req.flash('dbsuccess', { message: this.print.write('Record successfully removed'), record })
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('Record successfully removed'))
   }
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterRecordRemove`, id, options, record)
-    await runHook(`${this.name}:onAfterRecordRemove`, name, id, options, record)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordRemove`, id, options, record)
+    await runHook(`${this.name}:afterRecordRemove`, name, id, options, record)
   }
-  if (clearColl) await clearColl({ model: name, id, options, record })
+  if (clearModel) await clearModel({ model: name, id, options, record })
   if (noResult) return
-  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden })
+  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
   return dataOnly ? record.oldData : record
 }