dobo 1.0.2 → 1.0.4

package/bajo/method/record/update.js

@@ -6,54 +6,51 @@ import execFeatureHook from '../../../lib/exec-feature-hook.js'
 
 async function update (name, id, input, opts = {}) {
   const { runHook, isSet } = this.app.bajo
-  const { clearColl } = this.cache ?? {}
-  const { get, forOwn, find, cloneDeep } = this.app.bajo.lib._
-  const options = cloneDeep(opts)
+  const { clearModel } = this.cache ?? {}
+  const { forOwn, find, 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, partial = true, hidden } = options
+  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, partial = true, hidden, forceNoHidden } = options
   options.dataOnly = true
   options.truncateString = options.truncateString ?? true
   await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-update')
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-update', options)
   id = this.sanitizeId(id, schema)
-  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, partial, strict: true })
+  const extFields = get(options, 'validation.extFields', [])
+  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, partial, strict: true, extFields })
   delete body.id
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeRecordUpdate`, name, id, body, options)
-    await runHook(`${this.name}.${name}:onBeforeRecordUpdate`, id, body, options)
+    await runHook(`${this.name}:beforeRecordUpdate`, name, id, body, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeRecordUpdate`, id, body, options)
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'beforeUpdate', { schema, body })
-  if (!noValidation) body = await execValidation.call(this, { noHook, name, body, options, partial })
+  if (!noValidation) body = await execValidation.call(this, { name, body, options, partial })
   if (!noCheckUnique) await checkUnique.call(this, { schema, body, id })
-  let record
   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)
+    if (!prop) return undefined
+    if (options.truncateString && isSet(v) && ['string', 'text'].includes(prop.type)) v = v.slice(0, prop.maxLength)
     nbody[k] = v
   })
   delete nbody.id
-  try {
-    record = await handler.call(this.app[driver.ns], { schema, id, body: nbody, options })
-    if (options.req) {
-      if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, body, options, action: 'update' })
-      if (options.req.flash) options.req.flash('dbsuccess', { message: this.print.write('Record successfully updated'), record })
-    }
-  } catch (err) {
-    if (get(options, 'req.flash')) options.req.flash('dberr', err)
-    throw err
+  const record = await handler.call(this.app[driver.ns], { schema, id, body: nbody, options })
+  if (options.req) {
+    if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, body, options, action: 'update' })
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('Record successfully updated'))
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterRecordUpdate`, id, nbody, options, record)
-    await runHook(`${this.name}:onAfterRecordUpdate`, name, id, nbody, options, record)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
+    await runHook(`${this.name}:afterRecordUpdate`, name, id, nbody, options, record)
   }
-  if (clearColl) await clearColl({ model: name, id, body: nbody, options, record })
+  if (clearModel) await clearModel({ model: name, id, body: nbody, options, record })
   if (noResult) return
-  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden })
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden })
+  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   return dataOnly ? record.data : record
 }
 

package/bajo/method/record/upsert.js

@@ -1,8 +1,9 @@
 async function upsert (name, input, opts = {}) {
   const { generateId } = this.app.bajo
   const { find } = this.app.bajo.lib._
-  const { cloneDeep } = this.app.bajo.lib._
-  const options = cloneDeep(opts)
+  const { cloneDeep, omit } = this.app.bajo.lib._
+  const options = cloneDeep(omit(opts, ['req']))
+  options.req = opts.req
   options.dataOnly = options.dataOnly ?? true
   await this.modelExists(name, true)
   const { schema } = this.getInfo(name)
@@ -11,7 +12,7 @@ async function upsert (name, input, opts = {}) {
   if (idField.type === 'string') id = input.id ?? generateId()
   else if (idField.type === 'integer') id = input.id ?? generateId('int')
   id = this.sanitizeId(id, schema)
-  const old = await this.recordGet(name, id, { thrownNotFound: false, dataOnly: true, noHook: true, noCache: true })
+  const old = await this.recordGet(name, id, { thrownNotFound: false, dataOnly: true, noHook: true, noCache: true, force: true, hidden: options.hidden, forceNoHidden: options.forceNoHidden })
   if (old) return await this.recordUpdate(name, id, input, options)
   return await this.recordCreate(name, input, options)
 }

package/bajo/method/sanitize/body.js

@@ -1,8 +1,8 @@
-async function sanitizeBody ({ body = {}, schema = {}, partial, strict }) {
-  const { isSet, dayjs } = this.app.bajo
-  const { has, get, isString, isNumber } = this.app.bajo.lib._
+async function sanitizeBody ({ body = {}, schema = {}, partial, strict, extFields = [] }) {
+  const { isSet, dayjs, callHandler } = this.app.bajo
+  const { has, isString, isNumber, concat } = this.app.bajo.lib._
   const result = {}
-  for (const p of schema.properties) {
+  for (const p of concat(schema.properties, extFields)) {
     if (partial && !has(body, p.name)) continue
     if (['object', 'array'].includes(p.type)) {
       if (isString(body[p.name])) {
@@ -18,7 +18,7 @@ async function sanitizeBody ({ body = {}, schema = {}, partial, strict }) {
       }
     } else result[p.name] = body[p.name]
     if (isSet(body[p.name])) {
-      if (p.type === 'boolean') result[p.name] = result[p.name] === null ? null : (!!result[p.name])
+      if (p.type === 'boolean') result[p.name] = result[p.name] === null ? null : (['true', true].includes(result[p.name]))
       if (['float', 'double'].includes(p.type)) {
         if (isNumber(body[p.name])) result[p.name] = body[p.name]
         else if (strict) {
@@ -50,10 +50,9 @@ async function sanitizeBody ({ body = {}, schema = {}, partial, strict }) {
     } else {
       if (p.default) {
         result[p.name] = p.default
-        if (isString(p.default) && p.default.startsWith('helper:')) {
-          const helper = p.default.split(':')[1]
-          const method = get(this, helper)
-          if (method) result[p.name] = await this[method]()
+        if (isString(p.default) && p.default.startsWith('handler:')) {
+          const [, ...args] = p.default.split(':')
+          if (args.length > 0) result[p.name] = await callHandler(args.join(':'))
         } else {
           if (['float', 'double'].includes(p.type)) result[p.name] = parseFloat(result[p.name]) || null
           if (['integer', 'smallint'].includes(p.type)) result[p.name] = parseInt(result[p.name]) || null

package/bajo/method/stat/aggregate.js

@@ -5,17 +5,17 @@ async function aggregate (name, filter = {}, options = {}) {
   const { dataOnly = true, noHook, aggregate } = options
   options.dataOnly = false
   await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-aggregate')
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-aggregate', options)
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeStatAggregate`, name, aggregate, filter, options)
-    await runHook(`${this.name}.${name}:onBeforeStatAggregate`, aggregate, filter, options)
+    await runHook(`${this.name}:beforeStatAggregate`, name, aggregate, filter, options)
+    await runHook(`${this.name}.${name}:beforeStatAggregate`, aggregate, filter, options)
   }
-  const rec = await handler.call(this.app[driver.ns], { schema, filter, options })
   filter.query = await this.buildQuery({ filter, schema, options }) ?? {}
   filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
+  const rec = await handler.call(this.app[driver.ns], { schema, filter, options })
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterStatAggregate`, aggregate, filter, options, rec)
-    await runHook(`${this.name}:onAfterStatAggregate`, name, aggregate, filter, options, rec)
+    await runHook(`${this.name}.${name}:afterStatAggregate`, aggregate, filter, options, rec)
+    await runHook(`${this.name}:afterStatAggregate`, name, aggregate, filter, options, rec)
   }
   return dataOnly ? rec.data : rec
 }

package/bajo/method/stat/histogram.js

@@ -8,17 +8,17 @@ async function histogram (name, filter = {}, options = {}) {
   options.dataOnly = false
   if (!types.includes(type)) throw this.error('Histogram type must be one of these: %s', join(types))
   await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-histogram')
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-histogram', options)
   filter.query = await this.buildQuery({ filter, schema, options }) ?? {}
   filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeStatHistogram`, name, type, filter, options)
-    await runHook(`${this.name}.${name}:onBeforeStatHistogram`, type, filter, options)
+    await runHook(`${this.name}:beforeStatHistogram`, name, type, filter, options)
+    await runHook(`${this.name}.${name}:beforeStatHistogram`, type, filter, options)
   }
   const rec = await handler.call(this.app[driver.ns], { schema, type, filter, options })
   if (!noHook) {
-    await runHook(`${this.name}.${name}:onAfterStatHistogram`, type, filter, options, rec)
-    await runHook(`${this.name}:onAfterStatHistogram`, name, type, filter, options, rec)
+    await runHook(`${this.name}.${name}:afterStatHistogram`, type, filter, options, rec)
+    await runHook(`${this.name}:afterStatHistogram`, name, type, filter, options, rec)
   }
   return dataOnly ? rec.data : rec
 }

package/bajo/method/validate.js

@@ -15,25 +15,26 @@ const validator = {
   timestamp: ['timestamp']
 }
 
-function buildFromDbSchema (schema, { fields = [], rule = {}, extProperties = [] } = {}) {
+function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } = {}) {
   // if (schema.validation) return schema.validation
   const {
     isPlainObject, get, each, isEmpty, isString, forOwn, keys,
-    find, isArray, has, cloneDeep, concat
+    find, isArray, has, cloneDeep, concat, without
   } = this.app.bajo.lib._
   const obj = {}
   const me = this
+  const refs = []
 
-  function getRuleKv (rule) {
+  function getRuleKv (kvRule) {
     let key
     let value
     let columns
-    if (isPlainObject(rule)) {
-      key = rule.rule
-      value = rule.params
-      columns = rule.fields
-    } else if (isString(rule)) {
-      [key, value, columns] = rule.split(':')
+    if (isPlainObject(kvRule)) {
+      key = kvRule.rule
+      value = kvRule.params
+      columns = kvRule.fields
+    } else if (isString(kvRule)) {
+      [key, value, columns] = kvRule.split(':')
     }
     return { key, value, columns }
   }
@@ -42,30 +43,31 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extProperties = []
     const minMax = { min: false, max: false }
     const rules = get(rule, prop.name, prop.rules ?? [])
     if (!isArray(rules)) return rules
-    let isRef
     each(rules, r => {
       const types = validator[me.propType[prop.type].validator]
       const { key, value } = getRuleKv(r)
+      if (keys(minMax).includes(key)) minMax[key] = true
       if (key === 'ref') {
-        isRef = true
+        refs.push(prop.name)
         obj = joi.ref(value)
         return undefined
       }
       if (!key || !types.includes(key)) return undefined
-      if (keys(minMax).includes(key)) minMax[key] = true
       obj = obj[key](value)
     })
-    if (!isRef && ['string', 'text'].includes(prop.type)) {
+    if (refs.includes(prop.name)) return obj
+    if (['string', 'text'].includes(prop.type)) {
       forOwn(minMax, (v, k) => {
         if (v) return undefined
         if (has(prop, `${k}Length`)) obj = obj[k](prop[`${k}Length`])
       })
     }
-    if (!isRef && !['id'].includes(prop.name) && prop.required) obj = obj.required()
+    if (isArray(prop.values)) obj = obj.valid(...prop.values)
+    if (!['id'].includes(prop.name) && prop.required) obj = obj.required()
     return obj
   }
 
-  const props = concat(cloneDeep(schema.properties), extProperties)
+  const props = concat(cloneDeep(schema.properties), extFields)
 
   for (const p of props) {
     if (excludedTypes.includes(p.type) || excludedNames.includes(p.name)) continue
@@ -105,7 +107,7 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extProperties = []
   }
   if (isEmpty(obj)) return false
   each(get(schema, 'globalRules', []), r => {
-    each(keys(obj), k => {
+    each(without(keys(obj), ...refs), k => {
       const prop = find(props, { name: k })
       if (!prop) return undefined
       const types = validator[me.propType[prop.type].validator]
@@ -123,13 +125,14 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extProperties = []
   return result
 }
 
-async function validate (value, joiSchema, { ns, fields, extProperties, params } = {}) {
+async function validate (value, joiSchema, { ns, fields, extFields, params } = {}) {
   const { defaultsDeep, isSet } = this.app.bajo
   const { isString, forOwn, find } = this.app.bajo.lib._
 
   ns = ns ?? [this.name]
-  params = defaultsDeep(params, { abortEarly: false, convert: false, rule: undefined, allowUnknown: true })
-  const { rule } = params
+  params = defaultsDeep(params, this.config.validationParams)
+  const { rule = {} } = params
+  delete params.rule
   if (isString(joiSchema)) {
     const { schema } = this.getInfo(joiSchema)
     forOwn(value, (v, k) => {
@@ -141,7 +144,7 @@ async function validate (value, joiSchema, { ns, fields, extProperties, params }
         if (p.type === type) value[k] = this.sanitizeDate(value[k], { input, output: 'native' })
       }
     })
-    joiSchema = buildFromDbSchema.call(this, schema, { fields, rule, extProperties })
+    joiSchema = buildFromDbSchema.call(this, schema, { fields, rule, extFields })
   }
   if (!joiSchema) return value
   try {

package/bajo/start.js

@@ -1,3 +1,6 @@
+import memDbStart from '../lib/mem-db/start.js'
+import memDbInstantiate from '../lib/mem-db/instantiate.js'
+
 async function start (conns = 'all', noRebuild = true) {
   const { importModule, breakNsPath } = this.app.bajo
   const { find, filter, isString, map } = this.app.bajo.lib._
@@ -5,12 +8,13 @@ async function start (conns = 'all', noRebuild = true) {
   else if (isString(conns)) conns = filter(this.connections, { name: conns })
   else conns = map(conns, c => find(this.connections, { name: c }))
   for (const c of conns) {
-    const [ns] = breakNsPath(c.type)
+    const { ns } = breakNsPath(c.type)
     const schemas = filter(this.schemas, { connection: c.name })
-    const mod = await importModule(`${ns}:/${this.name}/boot/instantiate.js`)
+    const mod = c.type === 'dobo:memory' ? memDbInstantiate : await importModule(`${ns}:/${this.name}/boot/instantiate.js`)
     await mod.call(this.app[ns], { connection: c, noRebuild, schemas })
     this.log.trace('- Driver \'%s:%s\' instantiated', c.driver, c.name)
   }
+  await memDbStart.call(this)
 }
 
 export default start

package/bajoCli/applet/connection.js

@@ -1,4 +1,4 @@
-async function connection ({ path, args }) {
+async function connection (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map, find } = this.app.bajo.lib._
   const select = await importPkg('bajoCli:@inquirer/select')

package/bajoCli/applet/lib/post-process.js

@@ -1,26 +1,25 @@
 const conns = []
 
-async function postProcess ({ handler, params, path, processMsg, noConfirmation, options = {} } = {}) {
-  const { print, getConfig, saveAsDownload, importPkg, spinner } = this.app.bajo
+async function postProcess ({ handler, params, path, processMsg, noConfirmation } = {}) {
+  const { saveAsDownload, importPkg } = this.app.bajo
   const { prettyPrint } = this.app.bajoCli.helper
   const { find, get } = this.app.bajo.lib._
   const [stripAnsi, confirm] = await importPkg('bajoCli:strip-ansi', 'bajoCli:@inquirer/confirm')
-  const config = getConfig()
-  if (!noConfirmation && config.confirmation === false) noConfirmation = true
-  params.push({ fields: config.fields, dataOnly: !config.full })
+  if (!noConfirmation && this.config.confirmation === false) noConfirmation = true
+  params.push({ fields: this.config.fields, dataOnly: !this.config.full })
 
   const schema = find(this.schemas, { name: params[0] })
-  if (!schema) return print.fail('No schema found!', { exit: config.tool })
+  if (!schema) return this.print.fatal('No schema found!')
   let cont = true
   if (!noConfirmation) {
-    const answer = await confirm({ message: print.write('Are you sure to continue?'), default: false })
+    const answer = await confirm({ message: this.print.write('Are you sure to continue?'), default: false })
     if (!answer) {
-      print.fail('Aborted!')
+      this.print.fail('Aborted!')
       cont = false
     }
   }
   if (!cont) return
-  const spin = spinner().start(`${processMsg}...`)
+  const spin = this.print.spinner().start(`${processMsg}...`)
   const { connection } = this.getInfo(schema)
   if (!conns.includes(connection.name)) {
     await this.start(connection.name)
@@ -29,19 +28,20 @@ async function postProcess ({ handler, params, path, processMsg, noConfirmation,
   try {
     const resp = await this[handler](...params)
     spin.succeed('Done!')
-    const result = config.pretty ? (await prettyPrint(resp)) : JSON.stringify(resp, null, 2)
-    if (config.save) {
+    const result = this.config.pretty ? (await prettyPrint(resp)) : JSON.stringify(resp, null, 2)
+    if (this.config.save) {
       const id = resp.id ?? get(resp, 'data.id') ?? get(resp, 'oldData.id')
       const base = path === 'recordFind' ? params[0] : (params[0] + '/' + id)
-      const file = `/${path}/${base}.${config.pretty ? 'txt' : 'json'}`
+      const file = `/${path}/${base}.${this.config.pretty ? 'txt' : 'json'}`
       await saveAsDownload(file, stripAnsi(result))
     } else console.log(result)
   } catch (err) {
-    if (config.log.tool) {
+    if (this.config.log.applet) {
       spin.stop()
       console.error(err)
     } else spin.fail('Error: %s', err.message)
   }
+  process.exit()
 }
 
 export default postProcess

package/bajoCli/applet/model-clear.js

@@ -1,11 +1,11 @@
 import postProcess from './lib/post-process.js'
 
-async function modelClear ({ path, args, options }) {
+async function modelClear (...args) {
   const { print } = this.app.bajo
   const { isEmpty } = this.app.bajo.lib._
   if (isEmpty(this.schemas)) return print.fail('No schema found!', { exit: this.app.bajo.applet })
   const [schema] = args
-  await postProcess.call(this, { handler: 'modelClear', params: [schema], path, processMsg: 'Clear records', options })
+  await postProcess.call(this, { handler: 'modelClear', params: [schema], path: 'modelClear', processMsg: 'Clear records' })
 }
 
 export default modelClear

package/bajoCli/applet/model-rebuild.js

@@ -1,9 +1,9 @@
 import addFixtures from '../../lib/add-fixtures.js'
 
-async function modelRebuild ({ path, args }) {
-  const { importPkg, outmatch } = this.app.bajo
+async function modelRebuild (...args) {
+  const { importPkg } = this.app.bajo
+  const { outmatch } = this.app.bajo.lib
   const { isEmpty, map, trim } = this.app.bajo.lib._
-  const spinner = this.print.spinner
   const [input, confirm, boxen] = await importPkg('bajoCli:@inquirer/input',
     'bajoCli:@inquirer/confirm', 'bajoCli:boxen')
   const schemas = map(this.schemas, 'name')
@@ -25,26 +25,28 @@ async function modelRebuild ({ path, args }) {
     default: false
   })
   if (!answer) return this.print.fail('Aborted!', { exit: this.app.bajo.applet })
+  /*
   const conns = []
   for (const s of names) {
     const { connection } = this.getInfo(s)
     if (!conns.includes(connection.name)) conns.push(connection.name)
   }
-  await this.start(conns)
+  */
+  await this.start('all')
   const result = { succed: 0, failed: 0, skipped: 0 }
   for (const s of names) {
     const { schema, instance, connection } = this.getInfo(s)
-    const spin = spinner({ showCounter: true }).start('Rebuilding \'%s\'...', schema.name)
+    const spin = this.print.spinner({ showCounter: true }).start('Rebuilding \'%s\'...', schema.name)
     if (!instance) {
       spin.warn('Client instance not connected \'%s@%s\'. Skipped!', schema.connection, schema.name)
       result.skipped++
       continue
     }
-    const exists = await this.modelExists(schema, false, spinner)
+    const exists = await this.modelExists(schema.name, false, { spinner: spin })
     if (exists) {
       if (this.app.bajo.config.force) {
         try {
-          await this.modelDrop(schema, spinner)
+          await this.modelDrop(schema.name, { spinner: spin })
           spin.setText('Model \'%s\' successfully dropped', schema.name)
         } catch (err) {
           spin.fail('Error on dropping model \'%s\': %s', schema.name, err.message)
@@ -58,10 +60,10 @@ async function modelRebuild ({ path, args }) {
       }
     }
     try {
-      await this.modelCreate(schema, spinner)
+      await this.modelCreate(schema.name, { spinner: spin })
       if (connection.memory) spin.succeed('Model \'%s\' successfully created', schema.name)
       else {
-        const fixture = await addFixtures.call(this, schema, spin)
+        const fixture = await addFixtures.call(this, schema.name, { spinner: spin })
         spin.succeed('Model \'%s\' successfully created, with fixture: added %d, rejected: %s', schema.name, fixture.success, fixture.failed)
       }
       result.succed++
@@ -72,6 +74,7 @@ async function modelRebuild ({ path, args }) {
     }
   }
   this.print.info('Done! Succeded: %d, failed: %s, skipped: %d', result.succed, result.failed, result.skipped)
+  process.exit()
 }
 
 export default modelRebuild

package/bajoCli/applet/record-create.js

@@ -1,6 +1,6 @@
 import postProcess from './lib/post-process.js'
 
-async function createRecord ({ path, args, options }) {
+async function createRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map, isPlainObject } = this.app.bajo.lib._
   const [input, select, boxen] = await importPkg('bajoCli:@inquirer/input',
@@ -35,7 +35,7 @@ async function createRecord ({ path, args, options }) {
     return this.print.fail('Invalid payload syntax', { exit: this.app.bajo.applet })
   }
   console.log(boxen(JSON.stringify(payload, null, 2), { title: schema, padding: 0.5, borderStyle: 'round' }))
-  await postProcess.call(this, { handler: 'recordCreate', params: [schema, payload], path, processMsg: 'Creating record', options })
+  await postProcess.call(this, { handler: 'recordCreate', params: [schema, payload], path, processMsg: 'Creating record' })
 }
 
 export default createRecord

package/bajoCli/applet/record-find.js

@@ -1,6 +1,6 @@
 import postProcess from './lib/post-process.js'
 
-async function findRecord ({ path, args, options }) {
+async function findRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map, pick } = this.app.bajo.lib._
   const [select, input] = await importPkg('bajoCli:@inquirer/select', 'bajoCli:@inquirer/input')
@@ -21,7 +21,7 @@ async function findRecord ({ path, args, options }) {
   const filter = pick(this.app.bajo.config, ['page', 'offset', 'pageSize', 'sort', 'limit'])
   filter.pageSize = filter.pageSize ?? filter.limit
   filter.query = query
-  await postProcess.call(this, { noConfirmation: true, handler: 'recordFind', params: [schema, filter], path, processMsg: 'Finding record(s)', options })
+  await postProcess.call(this, { noConfirmation: true, handler: 'recordFind', params: [schema, filter], path, processMsg: 'Finding record(s)' })
 }
 
 export default findRecord

package/bajoCli/applet/record-get.js

@@ -1,6 +1,6 @@
 import postProcess from './lib/post-process.js'
 
-async function getRecord ({ path, args, options }) {
+async function getRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map } = this.app.bajo.lib._
   const [input, select] = await importPkg('bajoCli:@inquirer/input', 'bajoCli:@inquirer/select')
@@ -18,7 +18,7 @@ async function getRecord ({ path, args, options }) {
       validate: text => isEmpty(text) ? this.print.write('ID is required') : true
     })
   }
-  await postProcess.call(this, { noConfirmation: true, handler: 'recordGet', params: [schema, id], path, processMsg: 'Getting record', options })
+  await postProcess.call(this, { noConfirmation: true, handler: 'recordGet', params: [schema, id], path, processMsg: 'Getting record' })
 }
 
 export default getRecord

package/bajoCli/applet/record-remove.js

@@ -1,6 +1,6 @@
 import postProcess from './lib/post-process.js'
 
-async function removeRecord ({ path, args, options }) {
+async function removeRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map } = this.app.bajo.lib._
   const [input, select] = await importPkg('bajoCli:@inquirer/input', 'bajoCli:@inquirer/select')
@@ -18,7 +18,7 @@ async function removeRecord ({ path, args, options }) {
       validate: text => isEmpty(text) ? this.print.write('ID is required') : true
     })
   }
-  await postProcess.call(this, { handler: 'recordRemove', params: [schema, id], path, processMsg: 'Removing record', options })
+  await postProcess.call(this, { handler: 'recordRemove', params: [schema, id], path, processMsg: 'Removing record' })
 }
 
 export default removeRecord

package/bajoCli/applet/record-update.js

@@ -1,6 +1,6 @@
 import postProcess from './lib/post-process.js'
 
-async function updateRecord ({ path, args, options }) {
+async function updateRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map, isPlainObject } = this.app.bajo.lib._
   const [input, select, boxen] = await importPkg('bajoCli:@inquirer/input',
@@ -41,7 +41,7 @@ async function updateRecord ({ path, args, options }) {
     return this.print.fail('Invalid payload syntax', { exit: this.app.bajo.applet })
   }
   console.log(boxen(JSON.stringify(payload, null, 2), { title: schema, padding: 0.5, borderStyle: 'round' }))
-  await postProcess.call(this, { handler: 'recordUpdate', params: [schema, id, payload], path, processMsg: 'Updating record', options })
+  await postProcess.call(this, { handler: 'recordUpdate', params: [schema, id, payload], path, processMsg: 'Updating record' })
 }
 
 export default updateRecord

package/bajoCli/applet/schema.js

@@ -1,4 +1,4 @@
-async function schema ({ path, args }) {
+async function schema (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map, find } = this.app.bajo.lib._
   const { getOutputFormat, writeOutput } = this.app.bajoCli

package/bajoCli/applet/stat-count.js

@@ -1,6 +1,6 @@
 import postProcess from './lib/post-process.js'
 
-async function statCount ({ path, args, options }) {
+async function statCount (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map } = this.app.bajo.lib._
   const [select, input] = await importPkg('bajoCli:@inquirer/select', 'bajoCli:@inquirer/input')
@@ -18,7 +18,7 @@ async function statCount ({ path, args, options }) {
     })
   }
   const filter = { query }
-  await postProcess.call(this, { noConfirmation: true, handler: 'statCount', params: [schema, filter], path, processMsg: 'Counting record(s)', options })
+  await postProcess.call(this, { noConfirmation: true, handler: 'statCount', params: [schema, filter], path, processMsg: 'Counting record(s)' })
 }
 
 export default statCount