dobo 1.0.22 → 1.1.1

package/dobo/feature/removed-at.js

@@ -0,0 +1,85 @@
+async function beforeFind ({ filter = {}, options }, opts) {
+  filter.query = filter.query ?? {}
+  const { isEmpty, set } = this.app.bajo.lib._
+  const q = { $and: [] }
+  if (!isEmpty(filter.query)) {
+    if (filter.query.$and) q.$and.push(...filter.query.$and)
+    else q.$and.push(filter.query)
+  }
+  q.$and.push(set({}, opts.fieldName, null))
+  filter.query = q
+}
+
+async function afterFind ({ records }, opts) {
+  for (const rec of records.data) {
+    delete rec[opts.fieldName]
+  }
+}
+
+async function afterGet ({ schema, id, record }, opts) {
+  const { isEmpty } = this.app.bajo.lib._
+  if (!isEmpty(record.data[opts.fieldName])) throw this.error('recordNotFound%s%s', id, schema.name, { statusCode: 404 })
+  delete record.data[opts.fieldName]
+}
+
+async function beforeCreate ({ body }, opts) {
+  delete body[opts.fieldName]
+}
+
+async function afterCreate ({ record }, opts) {
+  delete record.data[opts.fieldName]
+  if (record.oldData) delete record.oldData[opts.fieldName]
+}
+
+async function removedAt (opts = {}) {
+  opts.fieldName = opts.fieldName ?? 'removedAt'
+  return {
+    properties: {
+      name: opts.fieldName,
+      type: 'datetime',
+      index: true
+    },
+    hook: {
+      beforeFind: async function ({ filter, options }) {
+        await beforeFind.call(this, { filter, options }, opts)
+      },
+      beforeFindOne: async function ({ filter, options }) {
+        await beforeFind.call(this, { filter, options }, opts)
+      },
+      afterFind: async function ({ records }) {
+        await afterFind.call(this, { records }, opts)
+      },
+      afterFindOne: async function ({ record }) {
+        await afterGet.call(this, { record }, opts)
+      },
+      afterGet: async function ({ record }) {
+        await afterGet.call(this, { record }, opts)
+      },
+      beforeCreate: async function ({ body }) {
+        await beforeCreate.call(this, { body }, opts)
+      },
+      afterCreate: async function ({ record }) {
+        await afterCreate.call(this, { record }, opts)
+      },
+      beforeUpdate: async function ({ schema, id, body, options }) {
+        await beforeCreate.call(this, { body }, opts)
+      },
+      afterUpdate: async function ({ record }) {
+        await afterCreate.call(this, { record }, opts)
+      },
+      beforeRemove: async function ({ schema, id, options }) {
+        const { recordUpdate, recordGet } = this.app.dobo
+        await recordGet(schema.name, id, options)
+        const { set } = this.app.bajo.lib._
+        const body = set({}, opts.fieldName, new Date())
+        const record = await recordUpdate(schema.name, id, body, { dataOnly: false, noValidation: true, noFeatureHook: true })
+        options.record = { oldData: record.oldData }
+      },
+      afterRemove: async function ({ record }) {
+        delete record.oldData[opts.fieldName]
+      }
+    }
+  }
+}
+
+export default removedAt

package/lib/exec-feature-hook.js

@@ -1,11 +1,12 @@
-async function execFeatureHook (name, { schema, body } = {}) {
+async function execFeatureHook (name, params = {}) {
   const { get } = this.app.bajo.lib._
+  const { schema } = params
   for (const f of schema.feature) {
     const fn = get(this.feature, f.name)
     if (!fn) continue
     const input = await fn.call(this, f)
     const hook = get(input, 'hook.' + name)
-    if (hook) await hook.call(this, { schema, body })
+    if (hook) await hook.call(this, params)
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dobo",
-  "version": "1.0.22",
+  "version": "1.1.1",
   "description": "Database ORM/ODM for Bajo Framework",
   "main": "index.js",
   "scripts": {

package/plugin/factory.js

@@ -0,0 +1,317 @@
+import collectConnections from '../lib/collect-connections.js'
+import collectDrivers from '../lib/collect-drivers.js'
+import collectFeature from '../lib/collect-feature.js'
+import collectSchemas from '../lib/collect-schemas.js'
+import memDbStart from '../lib/mem-db/start.js'
+import memDbInstantiate from '../lib/mem-db/instantiate.js'
+import nql from '@tryghost/nql'
+
+async function factory (pkgName) {
+  const me = this
+
+  return class Dobo extends this.lib.BajoPlugin {
+    constructor () {
+      super(pkgName, me.app)
+      this.alias = 'db'
+      this.config = {
+        connections: [],
+        mergeProps: ['connections'],
+        validationParams: {
+          abortEarly: false,
+          convert: false,
+          allowUnknown: true
+        },
+        default: {
+          property: {
+            text: {
+              kind: 'text'
+            },
+            string: {
+              length: 50
+            }
+          },
+          filter: {
+            limit: 25,
+            maxLimit: 200,
+            sort: ['dt:-1', 'updatedAt:-1', 'updated_at:-1', 'createdAt:-1', 'createdAt:-1', 'ts:-1', 'username', 'name']
+          },
+          idField: {
+            type: 'string',
+            maxLength: 50,
+            required: true,
+            index: { type: 'primary' }
+          }
+        },
+        memDb: {
+          createDefConnAtStart: true,
+          persistence: {
+            syncPeriod: 1
+          }
+        }
+      }
+      this.aggregateTypes = ['count', 'avg', 'min', 'max', 'sum']
+      this.propType = {
+        integer: {
+          validator: 'number'
+        },
+        smallint: {
+          validator: 'number'
+        },
+        text: {
+          validator: 'string',
+          kind: 'text',
+          choices: ['text', 'mediumtext', 'longtext']
+        },
+        string: {
+          validator: 'string',
+          maxLength: 255,
+          minLength: 0
+        },
+        float: {
+          validator: 'number'
+        },
+        double: {
+          validator: 'number'
+        },
+        boolean: {
+          validator: 'boolean'
+        },
+        date: {
+          validator: 'date'
+        },
+        datetime: {
+          validator: 'date'
+        },
+        time: {
+          validator: 'date'
+        },
+        timestamp: {
+          validator: 'timestamp'
+        },
+        object: {},
+        array: {}
+      }
+    }
+
+    init = async () => {
+      const { buildCollections } = this.app.bajo
+      const { fs } = this.app.bajo.lib
+      const checkType = async (item, items) => {
+        const { filter } = this.app.bajo.lib._
+        const existing = filter(items, { type: 'dobo:memory' })
+        if (existing.length > 1) this.fatal('onlyOneConnType%s', item.type)
+      }
+
+      fs.ensureDirSync(`${this.dir.data}/attachment`)
+      await collectDrivers.call(this)
+      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('notFound%s', this.print.write('connection'))
+      await collectFeature.call(this)
+      await collectSchemas.call(this)
+    }
+
+    start = async (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 = 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('driverInstantiated%s%s', c.driver, c.name)
+      }
+      await memDbStart.call(this)
+    }
+
+    pickRecord = async ({ record, fields, schema = {}, hidden = [], forceNoHidden } = {}) => {
+      const { isArray, pick, clone, isEmpty, omit } = this.app.bajo.lib._
+      const { dayjs } = this.app.bajo.lib
+
+      const transform = async ({ record, schema, hidden = [], forceNoHidden } = {}) => {
+        if (record._id) {
+          record.id = record._id
+          delete record._id
+        }
+        const defHidden = [...schema.hidden, ...hidden]
+        let result = {}
+        for (const p of schema.properties) {
+          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
+          }
+        }
+        result = await this.sanitizeBody({ body: result, schema, partial: true, ignoreNull: true })
+        if (record._rel) result._rel = record._rel
+        return result
+      }
+
+      if (isEmpty(record)) return record
+      if (hidden.length > 0) record = omit(record, hidden)
+      if (!isArray(fields)) return await transform.call(this, { record, schema, hidden, forceNoHidden })
+      const fl = clone(fields)
+      if (!fl.includes('id')) fl.unshift('id')
+      if (record._rel) fl.push('_rel')
+      return pick(await transform.call(this, { record, schema, hidden, forceNoHidden }), fl)
+    }
+
+    prepPagination = async (filter = {}, schema, options = {}) => {
+      const buildPageSkipLimit = (filter) => {
+        let limit = parseInt(filter.limit) || this.config.default.filter.limit
+        if (limit === -1) limit = this.config.default.filter.maxLimit
+        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
+        let skip = (page - 1) * limit
+        if (filter.skip) {
+          skip = parseInt(filter.skip) || skip
+          page = undefined
+        }
+        if (skip < 0) skip = 0
+        return { page, skip, limit }
+      }
+
+      const buildSort = (input, schema, allowSortUnindexed) => {
+        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.default.filter.sort, s => {
+            const [col] = s.split(':')
+            if (columns.includes(col)) {
+              input = s
+              return false
+            }
+          })
+        }
+        if (!isEmpty(input)) {
+          if (isPlainObject(input)) sort = input
+          else if (isString(input)) {
+            const item = {}
+            each(input.split('+'), text => {
+              let [col, dir] = map(trim(text).split(':'), i => trim(i))
+              dir = (dir ?? '').toUpperCase()
+              dir = dir === 'DESC' ? -1 : parseInt(dir) || 1
+              item[col] = dir / Math.abs(dir)
+            })
+            sort = item
+          }
+          if (schema) {
+            const items = keys(sort)
+            each(items, i => {
+              if (!schema.sortables.includes(i) && !allowSortUnindexed) throw this.error('sortOnUnindexedField%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)
+            })
+          }
+        }
+        return sort
+      }
+
+      const { page, skip, limit } = buildPageSkipLimit.call(this, filter)
+      let sortInput = filter.sort
+      try {
+        sortInput = JSON.parse(sortInput)
+      } catch (err) {}
+      const sort = buildSort.call(this, sortInput, schema, options.allowSortUnindexed)
+      return { limit, page, skip, sort }
+    }
+
+    buildMatch = ({ input = '', schema, options }) => {
+      const { isPlainObject, trim } = this.app.bajo.lib._
+      const split = (value, schema) => {
+        let [field, val] = value.split(':').map(i => i.trim())
+        if (!val) {
+          val = field
+          field = '*'
+        }
+        return { field, value: val }
+      }
+
+      input = trim(input)
+      let items = {}
+      if (isPlainObject(input)) items = input
+      else if (input[0] === '{') items = JSON.parse(input)
+      else {
+        for (const item of input.split('+').map(i => i.trim())) {
+          const part = split(item, schema)
+          if (!items[part.field]) items[part.field] = []
+          items[part.field].push(...part.value.split(' ').filter(v => ![''].includes(v)))
+        }
+      }
+      const matcher = {}
+      for (const f of schema.fullText.fields) {
+        const value = []
+        if (typeof items[f] === 'string') items[f] = [items[f]]
+        if (Object.prototype.hasOwnProperty.call(items, f)) value.push(...items[f])
+        matcher[f] = value
+      }
+      if (Object.prototype.hasOwnProperty.call(items, '*')) matcher['*'] = items['*']
+      return matcher
+    }
+
+    buildQuery = async ({ 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
+      return query
+    }
+
+    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
+    }
+
+    getConnection = (name) => {
+      const { find } = this.app.bajo.lib._
+      return find(this.connections, { name })
+    }
+
+    getInfo = (name) => {
+      const { breakNsPath } = this.app.bajo
+      const { find, map } = this.app.bajo.lib._
+      const schema = this.getSchema(name)
+      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
+      const returning = [map(schema.properties, 'name'), opts]
+      return { instance, driver, connection: conn, returning, schema }
+    }
+
+    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('unknownModelSchema%s', name)
+      return cloned ? cloneDeep(schema) : schema
+    }
+  }
+}
+
+export default factory

package/{bajo → plugin}/method/record/count.js

@@ -1,14 +1,16 @@
 import resolveMethod from '../../../lib/resolve-method.js'
+import execFeatureHook from '../../../lib/exec-feature-hook.js'
 
 async function count (name, filter = {}, opts = {}) {
   const { runHook } = this.app.bajo
   const { get, set } = this.cache ?? {}
   const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
   options.dataOnly = options.dataOnly ?? true
-  let { dataOnly, noHook, noCache } = options
+  let { dataOnly, noHook, noCache, noFeatureHook } = options
   options.dataOnly = false
   await this.modelExists(name, true)
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-count', options)
@@ -20,20 +22,23 @@ async function count (name, filter = {}, opts = {}) {
     await runHook(`${this.name}:beforeRecordCount`, name, filter, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeRecordCount`, filter, options)
   }
-  if (get && !noCache) {
+  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeCount', { schema, filter, options })
+  if (get && !noCache && !options.record) {
     const cachedResult = await get({ model: name, filter, options })
     if (cachedResult) {
       cachedResult.cached = true
       return dataOnly ? cachedResult.data : cachedResult
     }
   }
-  const count = await handler.call(this.app[driver.ns], { schema, filter, options })
+  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, count)
-    await runHook(`${this.name}:afterRecordCount`, name, filter, options, count)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordCount`, filter, options, record)
+    await runHook(`${this.name}:afterRecordCount`, name, filter, options, record)
   }
-  if (set && !noCache) await set({ model: name, filter, options, count })
-  return dataOnly ? count.data : count
+  if (set && !noCache) await set({ model: name, filter, options, record })
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterCount', { schema, filter, options, record })
+  return dataOnly ? record.data : record
 }
 
 export default count

package/{bajo → plugin}/method/record/create.js

@@ -10,6 +10,7 @@ async function create (name, input, opts = {}) {
   const { generateId, runHook, isSet } = this.app.bajo
   const { clearModel } = this.cache ?? {}
   const { find, forOwn, cloneDeep, camelCase, omit, get, pick } = this.app.bajo.lib._
+  delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
@@ -37,10 +38,8 @@ async function create (name, input, opts = {}) {
       }
     } else if (['integer', 'smallint'].includes(idField.type) && !idField.autoInc) input.id = generateId('int')
   }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeCreate', { schema, body })
   if (!noValidation) body = await execValidation.call(this, { name, body, options })
   if (isSet(body.id) && !noCheckUnique) await checkUnique.call(this, { schema, body })
-  let record = {}
   const nbody = {}
   forOwn(body, (v, k) => {
     if (v === undefined) return undefined
@@ -49,20 +48,22 @@ async function create (name, input, opts = {}) {
     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 (!noFeatureHook) await execFeatureHook.call(this, 'beforeCreate', { schema, body: nbody, options })
+  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, body: nbody, options }))
+  delete options.record
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, 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('recordCreated'))
   }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterCreate', { schema, body, record })
   if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordCreate`, body, options, record)
-    await runHook(`${this.name}:afterRecordCreate`, name, body, options, record)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordCreate`, nbody, options, record)
+    await runHook(`${this.name}:afterRecordCreate`, name, nbody, options, record)
   }
-  if (clearModel) await clearModel({ model: name, body, options, record })
+  if (clearModel) await clearModel({ model: name, body: nbody, options, record })
   if (noResult) return
   record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterCreate', { schema, body: nbody, options, record })
   return dataOnly ? record.data : record
 }
 

package/{bajo → plugin}/method/record/find-one.js

@@ -1,15 +1,17 @@
 import resolveMethod from '../../../lib/resolve-method.js'
 import singleRelRows from '../../../lib/single-rel-rows.js'
+import execFeatureHook from '../../../lib/exec-feature-hook.js'
 
 async function findOne (name, filter = {}, opts = {}) {
   const { runHook, isSet } = this.app.bajo
   const { get, set } = this.cache ?? {}
   const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
   options.dataOnly = options.dataOnly ?? true
-  let { fields, dataOnly, noHook, noCache, hidden, forceNoHidden } = options
+  let { fields, dataOnly, noHook, noCache, noFeatureHook, hidden, forceNoHidden } = options
   options.count = false
   options.dataOnly = false
   await this.modelExists(name, true)
@@ -23,15 +25,19 @@ async function findOne (name, filter = {}, opts = {}) {
     await runHook(`${this.name}:beforeRecordFindOne`, name, filter, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeRecordFindOne`, filter, options)
   }
-  if (get && !noCache) {
+  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeFindOne', { schema, filter, options })
+  if (get && !noCache && !options.record) {
     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 })
+  filter.limit = 1
+  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
+  delete options.record
   record.data = record.data[0]
+
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordFindOne`, filter, options, record)
@@ -39,6 +45,7 @@ async function findOne (name, filter = {}, opts = {}) {
   }
   record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (set && !noCache) await set({ model: name, filter, options, record })
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterFindOne', { schema, filter, options, record })
   return dataOnly ? record.data : record
 }
 

package/{bajo → plugin}/method/record/find.js

@@ -1,15 +1,17 @@
 import resolveMethod from '../../../lib/resolve-method.js'
 import multiRelRows from '../../../lib/multi-rel-rows.js'
+import execFeatureHook from '../../../lib/exec-feature-hook.js'
 
 async function find (name, filter = {}, opts = {}) {
   const { runHook, isSet } = this.app.bajo
   const { get, set } = this.cache ?? {}
   const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  delete opts.records
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
   options.dataOnly = options.dataOnly ?? true
-  let { fields, dataOnly, noHook, noCache, hidden, forceNoHidden } = options
+  let { fields, dataOnly, noHook, noCache, noFeatureHook, hidden, forceNoHidden } = options
   options.count = options.count ?? false
   options.dataOnly = false
   await this.modelExists(name, true)
@@ -22,14 +24,17 @@ async function find (name, filter = {}, opts = {}) {
     await runHook(`${this.name}:beforeRecordFind`, name, filter, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeRecordFind`, filter, options)
   }
-  if (get && !noCache) {
+  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeFind', { schema, filter, options })
+  if (get && !noCache && !options.records) {
     const cachedResult = await get({ model: name, filter, options })
     if (cachedResult) {
       cachedResult.cached = true
+      if (!noFeatureHook) await execFeatureHook.call(this, 'afterFind', { schema, filter, options, records: cachedResult })
       return dataOnly ? cachedResult.data : cachedResult
     }
   }
-  const records = await handler.call(this.app[driver.ns], { schema, filter, options })
+  const records = options.records ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
+  delete options.records
   if (isSet(options.rels)) await multiRelRows.call(this, { schema, records: records.data, options })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordFind`, filter, options, records)
@@ -39,6 +44,7 @@ async function find (name, filter = {}, opts = {}) {
     records.data[idx] = await this.pickRecord({ record: records.data[idx], fields, schema, hidden, forceNoHidden })
   }
   if (set && !noCache) await set({ model: name, filter, options, records })
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterFind', { schema, filter, options, records })
   return dataOnly ? records.data : records
 }
 

package/{bajo → plugin}/method/record/get.js

@@ -1,15 +1,17 @@
 import resolveMethod from '../../../lib/resolve-method.js'
 import singleRelRows from '../../../lib/single-rel-rows.js'
+import execFeatureHook from '../../../lib/exec-feature-hook.js'
 
 async function get (name, id, opts = {}) {
   const { runHook, isSet } = this.app.bajo
   const { get, set } = this.cache ?? {}
   const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
   options.dataOnly = options.dataOnly ?? true
-  let { fields, dataOnly, noHook, noCache, hidden = [], forceNoHidden } = options
+  let { fields, dataOnly, noHook, noCache, noFeatureHook, hidden = [], forceNoHidden } = options
   await this.modelExists(name, true)
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-get', options)
   if (!schema.cacheable) noCache = true
@@ -19,14 +21,17 @@ async function get (name, id, opts = {}) {
     await runHook(`${this.name}:beforeRecordGet`, name, id, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeRecordGet`, id, options)
   }
-  if (get && !noCache) {
+  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeGet', { schema, id, options })
+  if (get && !noCache && !options.record) {
     const cachedResult = await get({ model: name, id, options })
     if (cachedResult) {
       cachedResult.cached = true
+      if (!noFeatureHook) await execFeatureHook.call(this, 'afterGet', { schema, id, options, record: cachedResult })
       return dataOnly ? cachedResult.data : cachedResult
     }
   }
-  const record = await handler.call(this.app[driver.ns], { schema, id, options })
+  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, options }))
+  delete options.record
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordGet`, id, options, record)
@@ -35,6 +40,7 @@ async function get (name, id, opts = {}) {
   record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
 
   if (set && !noCache) await set({ model: name, id, options, record })
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterGet', { schema, id, options, record })
   return dataOnly ? record.data : record
 }
 

package/{bajo → plugin}/method/record/remove.js

@@ -1,15 +1,17 @@
 import resolveMethod from '../../../lib/resolve-method.js'
 import handleAttachmentUpload from '../../../lib/handle-attachment-upload.js'
+import execFeatureHook from '../../../lib/exec-feature-hook.js'
 
 async function remove (name, id, opts = {}) {
   const { runHook } = this.app.bajo
   const { clearModel } = this.cache ?? {}
   const { cloneDeep, camelCase, omit } = this.app.bajo.lib._
+  delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
   options.dataOnly = options.dataOnly ?? true
-  const { fields, dataOnly, noHook, noResult, hidden, forceNoHidden } = options
+  const { fields, dataOnly, noHook, noResult, noFeatureHook, hidden, forceNoHidden } = options
   options.dataOnly = false
   await this.modelExists(name, true)
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-remove', options)
@@ -18,7 +20,9 @@ async function remove (name, id, opts = {}) {
     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 (!noFeatureHook) await execFeatureHook.call(this, 'beforeRemove', { schema, id, options })
+  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, options }))
+  delete options.record
   if (options.req) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, options, action: 'remove' })
     if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordRemoved'))
@@ -29,7 +33,8 @@ async function remove (name, id, opts = {}) {
   }
   if (clearModel) await clearModel({ model: name, id, options, record })
   if (noResult) return
-  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
+  record.oldData = options.record ? options.record.oldData : (await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden }))
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterRemove', { schema, id, options, record })
   return dataOnly ? record.oldData : record
 }
 

package/{bajo → plugin}/method/record/update.js

@@ -9,6 +9,7 @@ async function update (name, id, input, opts = {}) {
   const { runHook, isSet } = this.app.bajo
   const { clearModel } = this.cache ?? {}
   const { forOwn, find, cloneDeep, camelCase, omit, get } = this.app.bajo.lib._
+  delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
   options.reply = opts.reply
@@ -27,7 +28,6 @@ async function update (name, id, input, opts = {}) {
     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, { name, body, options, partial })
   if (!noCheckUnique) await checkUnique.call(this, { schema, body, id })
   const nbody = {}
@@ -39,13 +39,14 @@ async function update (name, id, input, opts = {}) {
     nbody[k] = v
   })
   delete nbody.id
-  const record = await handler.call(this.app[driver.ns], { schema, id, body: nbody, options })
+  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeUpdate', { schema, body: nbody, options })
+  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, body: nbody, options }))
+  delete options.record
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, 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('recordUpdated'))
   }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
     await runHook(`${this.name}:afterRecordUpdate`, name, id, nbody, options, record)
@@ -54,6 +55,7 @@ async function update (name, id, input, opts = {}) {
   if (noResult) return
   record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
   record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
+  if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
   return dataOnly ? record.data : record
 }
 

package/waibuMpa/route/attachment/@model/@id/@field/@file.js

@@ -1,12 +1,19 @@
 import path from 'path'
 
 async function attachment (req, reply) {
+  const { isString } = this.app.bajo.lib._
   const { importPkg, getPluginDataDir, pascalCase } = this.app.bajo
+  const { routePath } = this.app.waibu
   const mime = await importPkg('waibu:mime')
   const { fs } = this.app.bajo.lib
   const file = `${getPluginDataDir('dobo')}/attachment/${pascalCase(req.params.model)}/${req.params.id}/${req.params.field}/${req.params.file}`
-  if (!fs.existsSync(file)) throw this.error('_notFound', { noView: true })
   const mimeType = mime.getType(path.extname(file))
+  if (!fs.existsSync(file)) {
+    if (!req.query.notfound) throw this.error('_notFound', { noView: true })
+    const [, ext] = mimeType.split('/')
+    const replacer = isString(req.query.notfound) ? req.query.notfound : `waibuStatic.asset:/not-found.${ext}`
+    return reply.redirectTo(routePath(replacer))
+  }
   reply.header('Content-Type', mimeType)
   const stream = fs.createReadStream(file)
   reply.send(stream)

package/bajo/.alias

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

package/bajo/config.json

@@ -1,36 +0,0 @@
-{
-  "connections": [],
-  "mergeProps": ["connections"],
-  "validationParams": {
-    "abortEarly": false,
-    "convert": false,
-    "allowUnknown": true
-  },
-  "default": {
-    "property": {
-      "text": {
-        "kind": "text"
-      },
-      "string": {
-        "length": 50
-      }
-    },
-    "filter": {
-      "limit": 25,
-      "maxLimit": 200,
-      "sort": ["dt:-1", "updatedAt:-1", "updated_at:-1", "createdAt:-1", "createdAt:-1", "ts:-1", "username", "name"]
-    },
-    "idField": {
-      "type": "string",
-      "maxLength": 50,
-      "required": true,
-      "index": { "type": "primary" }
-    }
-  },
-  "memDb": {
-    "createDefConnAtStart": true,
-    "persistence": {
-      "syncPeriod": 1
-    }
-  }
-}

package/bajo/init.js

@@ -1,29 +0,0 @@
-import collectConnections from '../lib/collect-connections.js'
-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('onlyOneConnType%s', item.type)
-}
-
-async function init () {
-  const { buildCollections } = this.app.bajo
-  const { fs } = this.app.bajo.lib
-  fs.ensureDirSync(`${this.dir.data}/attachment`)
-  await collectDrivers.call(this)
-  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('notFound%s', this.print.write('connection'))
-  await collectFeature.call(this)
-  await collectSchemas.call(this)
-}
-
-export default init

package/bajo/method/aggregate-types.js

@@ -1 +0,0 @@
-export default ['count', 'avg', 'min', 'max', 'sum']

package/bajo/method/build-match.js

@@ -1,34 +0,0 @@
-function split (value, schema) {
-  let [field, val] = value.split(':').map(i => i.trim())
-  if (!val) {
-    val = field
-    field = '*'
-  }
-  return { field, value: val }
-}
-
-function buildMatch ({ input = '', schema, options }) {
-  const { isPlainObject, trim } = this.app.bajo.lib._
-  input = trim(input)
-  let items = {}
-  if (isPlainObject(input)) items = input
-  else if (input[0] === '{') items = JSON.parse(input)
-  else {
-    for (const item of input.split('+').map(i => i.trim())) {
-      const part = split.call(this, item, schema)
-      if (!items[part.field]) items[part.field] = []
-      items[part.field].push(...part.value.split(' ').filter(v => ![''].includes(v)))
-    }
-  }
-  const matcher = {}
-  for (const f of schema.fullText.fields) {
-    const value = []
-    if (typeof items[f] === 'string') items[f] = [items[f]]
-    if (Object.prototype.hasOwnProperty.call(items, f)) value.push(...items[f])
-    matcher[f] = value
-  }
-  if (Object.prototype.hasOwnProperty.call(items, '*')) matcher['*'] = items['*']
-  return matcher
-}
-
-export default buildMatch

package/bajo/method/build-query.js

@@ -1,14 +0,0 @@
-import nql from '@tryghost/nql'
-
-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
-  return query
-}
-
-export default buildQuery

package/bajo/method/get-connection.js

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

package/bajo/method/get-info.js

@@ -1,14 +0,0 @@
-function getInfo (name) {
-  const { breakNsPath } = this.app.bajo
-  const { find, map } = this.app.bajo.lib._
-  const schema = this.getSchema(name)
-  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
-  const returning = [map(schema.properties, 'name'), opts]
-  return { instance, driver, connection: conn, returning, schema }
-}
-
-export default getInfo

package/bajo/method/get-schema.js

@@ -1,10 +0,0 @@
-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('unknownModelSchema%s', name)
-  return cloned ? cloneDeep(schema) : schema
-}
-
-export default getSchema

package/bajo/method/pick-record.js

@@ -1,36 +0,0 @@
-async function transform ({ record, schema, hidden = [], forceNoHidden } = {}) {
-  const { dayjs } = this.app.bajo.lib
-  if (record._id) {
-    record.id = record._id
-    delete record._id
-  }
-  const defHidden = [...schema.hidden, ...hidden]
-  let result = {}
-  for (const p of schema.properties) {
-    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
-    }
-  }
-  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 = [], 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, forceNoHidden })
-  const fl = clone(fields)
-  if (!fl.includes('id')) fl.unshift('id')
-  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,63 +0,0 @@
-function buildPageSkipLimit (filter) {
-  let limit = parseInt(filter.limit) || this.config.default.filter.limit
-  if (limit === -1) limit = this.config.default.filter.maxLimit
-  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
-  let skip = (page - 1) * limit
-  if (filter.skip) {
-    skip = parseInt(filter.skip) || skip
-    page = undefined
-  }
-  if (skip < 0) skip = 0
-  return { page, skip, limit }
-}
-
-function buildSort (input, schema, allowSortUnindexed) {
-  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.default.filter.sort, s => {
-      const [col] = s.split(':')
-      if (columns.includes(col)) {
-        input = s
-        return false
-      }
-    })
-  }
-  if (!isEmpty(input)) {
-    if (isPlainObject(input)) sort = input
-    else if (isString(input)) {
-      const item = {}
-      each(input.split('+'), text => {
-        let [col, dir] = map(trim(text).split(':'), i => trim(i))
-        dir = (dir ?? '').toUpperCase()
-        dir = dir === 'DESC' ? -1 : parseInt(dir) || 1
-        item[col] = dir / Math.abs(dir)
-      })
-      sort = item
-    }
-    if (schema) {
-      const items = keys(sort)
-      each(items, i => {
-        if (!schema.sortables.includes(i) && !allowSortUnindexed) throw this.error('sortOnUnindexedField%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)
-      })
-    }
-  }
-  return sort
-}
-
-async function prepPagination (filter = {}, schema, options = {}) {
-  const { page, skip, limit } = buildPageSkipLimit.call(this, filter)
-  let sortInput = filter.sort
-  try {
-    sortInput = JSON.parse(sortInput)
-  } catch (err) {}
-  const sort = buildSort.call(this, sortInput, schema, options.allowSortUnindexed)
-  return { limit, page, skip, sort }
-}
-
-export default prepPagination

package/bajo/method/prop-type.js

@@ -1,43 +0,0 @@
-const propType = {
-  integer: {
-    validator: 'number'
-  },
-  smallint: {
-    validator: 'number'
-  },
-  text: {
-    validator: 'string',
-    kind: 'text',
-    choices: ['text', 'mediumtext', 'longtext']
-  },
-  string: {
-    validator: 'string',
-    maxLength: 255,
-    minLength: 0
-  },
-  float: {
-    validator: 'number'
-  },
-  double: {
-    validator: 'number'
-  },
-  boolean: {
-    validator: 'boolean'
-  },
-  date: {
-    validator: 'date'
-  },
-  datetime: {
-    validator: 'date'
-  },
-  time: {
-    validator: 'date'
-  },
-  timestamp: {
-    validator: 'timestamp'
-  },
-  object: {},
-  array: {}
-}
-
-export default propType

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

@@ -1,12 +0,0 @@
-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