dobo 1.0.0 → 1.0.1

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

@@ -0,0 +1,15 @@
+async function findAll (name, filter = {}, options = {}) {
+  filter.page = 1
+  filter.limit = 100
+  options.dataOnly = true
+  const all = []
+  for (;;) {
+    const results = await this.recordFind(name, filter, options)
+    if (results.length === 0) break
+    all.push(...results)
+    filter.page++
+  }
+  return all
+}
+
+export default findAll

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

@@ -0,0 +1,39 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+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)
+  options.dataOnly = options.dataOnly ?? true
+  const { fields, dataOnly, noHook, noCache, hidden } = 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')
+  if (!noHook) {
+    await runHook(`${this.name}:onBeforeRecordFindOne`, name, filter, options)
+    await runHook(`${this.name}.${name}:onBeforeRecordFindOne`, filter, options)
+  }
+  if (get && !noCache) {
+    const cachedResult = await get({ model: name, filter, options })
+    if (cachedResult) {
+      cachedResult.cached = true
+      return dataOnly ? cachedResult.data : cachedResult
+    }
+  }
+  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)
+  }
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden })
+  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
+}
+
+export default findOne

package/bajo/method/record/find.js

@@ -0,0 +1,41 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+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)
+  options.dataOnly = options.dataOnly ?? true
+  const { fields, dataOnly, noHook, noCache, hidden } = 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')
+  filter.query = await this.buildQuery({ filter, schema, options }) ?? {}
+  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)
+  }
+  if (get && !noCache) {
+    const cachedResult = await get({ model: name, filter, options })
+    if (cachedResult) {
+      cachedResult.cached = true
+      return dataOnly ? cachedResult.data : cachedResult
+    }
+  }
+  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)
+  }
+  for (const idx in records.data) {
+    records.data[idx] = await this.pickRecord({ record: records.data[idx], fields, schema, hidden })
+  }
+  if (isSet(options.rels)) await multiRelRows.call(this, { schema, records: records.data, options })
+  if (set && !noCache) await set({ model: name, filter, options, records })
+  return dataOnly ? records.data : records
+}
+
+export default find

package/bajo/method/record/get.js

@@ -0,0 +1,38 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+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)
+  options.dataOnly = options.dataOnly ?? true
+  const { fields, dataOnly, noHook, noCache, hidden = [] } = options
+  await this.modelExists(name, true)
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-get')
+  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)
+  }
+  if (get && !noCache) {
+    const cachedResult = await get({ model: name, id, options })
+    if (cachedResult) {
+      cachedResult.cached = true
+      return dataOnly ? cachedResult.data : cachedResult
+    }
+  }
+  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)
+  }
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden })
+  if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
+
+  if (set && !noCache) await set({ model: name, id, options, record })
+  return dataOnly ? record.data : record
+}
+
+export default get

package/bajo/method/record/remove.js

@@ -0,0 +1,34 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+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)
+  options.dataOnly = options.dataOnly ?? true
+  const { fields, dataOnly, noHook, noResult, hidden } = options
+  options.dataOnly = false
+  await this.modelExists(name, true)
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-remove')
+  id = this.sanitizeId(id, schema)
+  if (!noHook) {
+    await runHook(`${this.name}:onBeforeRecordRemove`, name, id, options)
+    await runHook(`${this.name}.${name}:onBeforeRecordRemove`, 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 (!noHook) {
+    await runHook(`${this.name}.${name}:onAfterRecordRemove`, id, options, record)
+    await runHook(`${this.name}:onAfterRecordRemove`, name, id, options, record)
+  }
+  if (clearColl) await clearColl({ model: name, id, options, record })
+  if (noResult) return
+  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden })
+  return dataOnly ? record.oldData : record
+}
+
+export default remove

package/bajo/method/record/update.js

@@ -0,0 +1,60 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+import checkUnique from '../../../lib/check-unique.js'
+import handleAttachmentUpload from '../../../lib/handle-attachment-upload.js'
+import execValidation from '../../../lib/exec-validation.js'
+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)
+  options.dataOnly = options.dataOnly ?? true
+  input = cloneDeep(input)
+  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, partial = true, hidden } = 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')
+  id = this.sanitizeId(id, schema)
+  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, partial, strict: true })
+  delete body.id
+  if (!noHook) {
+    await runHook(`${this.name}:onBeforeRecordUpdate`, name, id, body, options)
+    await runHook(`${this.name}.${name}:onBeforeRecordUpdate`, 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 (!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)
+    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
+  }
+  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)
+  }
+  if (clearColl) await clearColl({ 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 })
+  return dataOnly ? record.data : record
+}
+
+export default update

package/bajo/method/record/upsert.js

@@ -0,0 +1,19 @@
+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)
+  options.dataOnly = options.dataOnly ?? true
+  await this.modelExists(name, true)
+  const { schema } = this.getInfo(name)
+  const idField = find(schema.properties, { name: 'id' })
+  let id
+  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 })
+  if (old) return await this.recordUpdate(name, id, input, options)
+  return await this.recordCreate(name, input, options)
+}
+
+export default upsert

package/bajo/method/sanitize/body.js

@@ -0,0 +1,67 @@
+async function sanitizeBody ({ body = {}, schema = {}, partial, strict }) {
+  const { isSet, dayjs } = this.app.bajo
+  const { has, get, isString, isNumber } = this.app.bajo.lib._
+  const result = {}
+  for (const p of schema.properties) {
+    if (partial && !has(body, p.name)) continue
+    if (['object', 'array'].includes(p.type)) {
+      if (isString(body[p.name])) {
+        try {
+          result[p.name] = JSON.parse(body[p.name])
+        } catch (err) {
+          result[p.name] = null
+        }
+      } else {
+        try {
+          result[p.name] = JSON.parse(JSON.stringify(body[p.name]))
+        } catch (err) {}
+      }
+    } 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 (['float', 'double'].includes(p.type)) {
+        if (isNumber(body[p.name])) result[p.name] = body[p.name]
+        else if (strict) {
+          result[p.name] = Number(body[p.name])
+        } else {
+          result[p.name] = parseFloat(body[p.name]) || null
+        }
+      }
+      if (['integer', 'smallint'].includes(p.type)) {
+        if (isNumber(body[p.name])) result[p.name] = body[p.name]
+        else if (strict) {
+          result[p.name] = Number(body[p.name])
+        } else {
+          result[p.name] = parseInt(body[p.name]) || null
+        }
+      }
+      if (p.type === 'timestamp') {
+        if (!isNumber(body[p.name])) result[p.name] = -1
+        else {
+          const dt = dayjs.unix(body[p.name])
+          result[p.name] = dt.isValid() ? dt.unix() : -1
+        }
+      } else {
+        for (const t of ['datetime', 'date|YYYY-MM-DD', 'time|HH:mm:ss']) {
+          const [type, input] = t.split('|')
+          if (p.type === type) result[p.name] = this.sanitizeDate(body[p.name], { input })
+        }
+      }
+    } 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]()
+        } 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
+        }
+      }
+    }
+  }
+  return result
+}
+
+export default sanitizeBody

package/bajo/method/sanitize/date.js

@@ -0,0 +1,14 @@
+function sanitizeDate (value, { input, output, silent = true } = {}) {
+  const { dayjs } = this.app.bajo.lib
+  if (value === 0) return null
+  if (!output) output = input
+  const dt = dayjs(value, input)
+  if (!dt.isValid()) {
+    if (silent) return -1
+    throw this.error('Invalid date')
+  }
+  if (output === 'native' || !output) return dt.toDate()
+  return dt.format(output)
+}
+
+export default sanitizeDate

package/bajo/method/sanitize/id.js

@@ -0,0 +1,7 @@
+function sanitizeId (id, schema) {
+  const prop = schema.properties.find(p => p.name === 'id')
+  if (prop.type === 'integer') id = parseInt(id)
+  return id
+}
+
+export default sanitizeId

package/bajo/method/stat/aggregate.js

@@ -0,0 +1,23 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+
+async function aggregate (name, filter = {}, options = {}) {
+  const { runHook } = this.app.bajo
+  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')
+  if (!noHook) {
+    await runHook(`${this.name}:onBeforeStatAggregate`, name, aggregate, filter, options)
+    await runHook(`${this.name}.${name}:onBeforeStatAggregate`, 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 }) ?? {}
+  if (!noHook) {
+    await runHook(`${this.name}.${name}:onAfterStatAggregate`, aggregate, filter, options, rec)
+    await runHook(`${this.name}:onAfterStatAggregate`, name, aggregate, filter, options, rec)
+  }
+  return dataOnly ? rec.data : rec
+}
+
+export default aggregate

package/bajo/method/stat/histogram.js

@@ -0,0 +1,26 @@
+import resolveMethod from '../../../lib/resolve-method.js'
+
+const types = ['daily', 'monthly', 'yearly']
+
+async function histogram (name, filter = {}, options = {}) {
+  const { runHook, join } = this.app.bajo
+  const { dataOnly = true, noHook, type } = 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')
+  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)
+  }
+  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)
+  }
+  return dataOnly ? rec.data : rec
+}
+
+export default histogram

package/bajo/method/validate.js

@@ -0,0 +1,154 @@
+import joi from 'joi'
+
+const excludedTypes = ['object', 'array']
+const excludedNames = []
+
+const validator = {
+  string: ['alphanum', 'base64', 'case', 'creditCard', 'dataUri', 'domain', 'email', 'guid',
+    'uuid', 'hex', 'hostname', 'insensitive', 'ip', 'isoDate', 'isoDuration', 'length', 'lowercase',
+    'max', 'min', 'normalize', 'pattern', 'regex', 'replace', 'token', 'trim', 'truncate',
+    'uppercase', 'uri'],
+  number: ['great', 'less', 'max', 'min', 'multiple', 'negative', 'port', 'positive',
+    'sign', 'unsafe'],
+  boolean: ['falsy', 'sensitive', 'truthy'],
+  date: ['greater', 'iso', 'less', 'max', 'min'],
+  timestamp: ['timestamp']
+}
+
+function buildFromDbSchema (schema, { fields = [], rule = {}, extProperties = [] } = {}) {
+  // if (schema.validation) return schema.validation
+  const {
+    isPlainObject, get, each, isEmpty, isString, forOwn, keys,
+    find, isArray, has, cloneDeep, concat
+  } = this.app.bajo.lib._
+  const obj = {}
+  const me = this
+
+  function getRuleKv (rule) {
+    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(':')
+    }
+    return { key, value, columns }
+  }
+
+  function applyFieldRules (prop, obj) {
+    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 (key === 'ref') {
+        isRef = true
+        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)) {
+      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()
+    return obj
+  }
+
+  const props = concat(cloneDeep(schema.properties), extProperties)
+
+  for (const p of props) {
+    if (excludedTypes.includes(p.type) || excludedNames.includes(p.name)) continue
+    if (fields.length > 0 && !fields.includes(p.name)) continue
+    let item
+    switch (p.type) {
+      case 'text':
+      case 'string': {
+        item = applyFieldRules(p, joi.string())
+        break
+      }
+      case 'smallint':
+      case 'integer':
+        item = applyFieldRules(p, joi.number().integer())
+        break
+      case 'float':
+      case 'double':
+        if (p.precision) item = applyFieldRules(p, joi.number().precision(p.precision))
+        else item = applyFieldRules(p, joi.number())
+        break
+      case 'time':
+      case 'date':
+      case 'datetime':
+        item = applyFieldRules(p, joi.date())
+        break
+      case 'timestamp':
+        item = applyFieldRules(p, joi.number().integer())
+        break
+      case 'boolean':
+        item = applyFieldRules(p, joi.boolean())
+        break
+    }
+    if (item) {
+      if (item.$_root) obj[p.name] = item.allow(null)
+      else obj[p.name] = item
+    }
+  }
+  if (isEmpty(obj)) return false
+  each(get(schema, 'globalRules', []), r => {
+    each(keys(obj), k => {
+      const prop = find(props, { name: k })
+      if (!prop) return undefined
+      const types = validator[me.propType[prop.type].validator]
+      const { key, value, columns = [] } = getRuleKv(r)
+      if (!types.includes(key)) return undefined
+      if (columns.length === 0 || columns.includes(k)) obj[k] = obj[k][key](value)
+    })
+  })
+  const result = joi.object(obj)
+  if (fields.length === 0) return result
+  each(['with', 'xor', 'without'], k => {
+    const item = get(schema, `extRule.${k}`)
+    if (item) result[k](...item)
+  })
+  return result
+}
+
+async function validate (value, joiSchema, { ns, fields, extProperties, 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
+  if (isString(joiSchema)) {
+    const { schema } = this.getInfo(joiSchema)
+    forOwn(value, (v, k) => {
+      if (!isSet(v)) return undefined
+      const p = find(schema.properties, { name: k })
+      if (!p) return undefined
+      for (const t of ['date|YYYY-MM-DD', 'time|HH:mm:ss']) {
+        const [type, input] = t.split('|')
+        if (p.type === type) value[k] = this.sanitizeDate(value[k], { input, output: 'native' })
+      }
+    })
+    joiSchema = buildFromDbSchema.call(this, schema, { fields, rule, extProperties })
+  }
+  if (!joiSchema) return value
+  try {
+    return await joiSchema.validateAsync(value, params)
+  } catch (err) {
+    throw this.error('Validation Error', { details: err.details, values: err.values, ns, statusCode: 422, code: 'DB_VALIDATION' })
+  }
+}
+
+export default validate

package/bajo/method/validation-error-message.js

@@ -0,0 +1,12 @@
+function validationErrorMessage (err) {
+  let text = err.message
+  if (err.details) {
+    text += ' -> '
+    text += this.app.bajo.join(err.details.map((d, idx) => {
+      return `${d.field}@${err.model}: ${d.error} (${d.value})`
+    }))
+  }
+  return text
+}
+
+export default validationErrorMessage

package/bajo/start.js

@@ -0,0 +1,16 @@
+async function start (conns = 'all', noRebuild = true) {
+  const { importModule, breakNsPath } = this.app.bajo
+  const { find, filter, isString, map } = this.app.bajo.lib._
+  if (conns === 'all') conns = this.connections
+  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 schemas = filter(this.schemas, { connection: c.name })
+    const mod = 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)
+  }
+}
+
+export default start

package/bajoCli/applet/connection.js

@@ -0,0 +1,22 @@
+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')
+  const { getOutputFormat, writeOutput } = this.app.bajoCli
+  const format = getOutputFormat()
+  if (isEmpty(this.connections)) return this.print.fail('No connection found!', { exit: this.app.bajo.applet })
+  let name = args[0]
+  if (isEmpty(name)) {
+    const choices = map(this.connections, s => ({ value: s.name }))
+    name = await select({
+      message: this.print.write('Please choose a connection:'),
+      choices
+    })
+  }
+  const result = find(this.connections, { name })
+  if (!result) return this.print.fail('Can\'t find %s named \'%s\'', this.print.write('connection'), name, { exit: this.app.bajo.applet })
+  this.print.info('Done!')
+  await writeOutput(result, path, format)
+}
+
+export default connection

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

@@ -0,0 +1,47 @@
+const conns = []
+
+async function postProcess ({ handler, params, path, processMsg, noConfirmation, options = {} } = {}) {
+  const { print, getConfig, saveAsDownload, importPkg, spinner } = 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 })
+
+  const schema = find(this.schemas, { name: params[0] })
+  if (!schema) return print.fail('No schema found!', { exit: config.tool })
+  let cont = true
+  if (!noConfirmation) {
+    const answer = await confirm({ message: print.write('Are you sure to continue?'), default: false })
+    if (!answer) {
+      print.fail('Aborted!')
+      cont = false
+    }
+  }
+  if (!cont) return
+  const spin = spinner().start(`${processMsg}...`)
+  const { connection } = this.getInfo(schema)
+  if (!conns.includes(connection.name)) {
+    await this.start(connection.name)
+    conns.push(connection.name)
+  }
+  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 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'}`
+      await saveAsDownload(file, stripAnsi(result))
+    } else console.log(result)
+  } catch (err) {
+    if (config.log.tool) {
+      spin.stop()
+      console.error(err)
+    } else spin.fail('Error: %s', err.message)
+  }
+}
+
+export default postProcess

package/bajoCli/applet/model-clear.js

@@ -0,0 +1,11 @@
+import postProcess from './lib/post-process.js'
+
+async function modelClear ({ path, args, options }) {
+  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 })
+}
+
+export default modelClear