dobo 2.0.1 → 2.2.1

package/index.js

@@ -1,42 +1,10 @@
 import collectConnections from './lib/collect-connections.js'
 import collectDrivers from './lib/collect-drivers.js'
 import collectFeatures from './lib/collect-features.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'
-import path from 'path'
+import collectModels from './lib/collect-models.js'
 
 /**
- * @typedef {string} TRecordSortKey
- */
-
-/**
- * Key value pairs used as sort information:
- * - Key represent model's field name
- * - value represent its sort order: ```1``` for ascending order, and ```-1``` for descending order
- *
- * Example: to sort by firstName (ascending) and lastName (descending)
- * ```javascript
- * const sort = {
- *   firstName: 1,
- *   lastName: -1
- * }
- * ```
- *
- * @typedef {Object.<string, TRecordSortKey>} TRecordSort
- */
-
-/**
- * @typedef {Object} TRecordPagination
- * @property {number} limit - Number of records per page
- * @property {number} page - Page number
- * @property {number} skip - Records to skip
- * @property {TRecordSort} sort - Sort order
- */
-
-/**
- * @typedef {Object} TPropType
+ * @typedef {Object} TPropertyType
  * @property {Object} integer
  * @property {string} [integer.validator=number]
  * @property {Object} smallint
@@ -66,48 +34,55 @@ import path from 'path'
  * @property {Object} object={}
  * @property {Object} array={}
  */
-const propType = {
+const propertyType = {
   integer: {
-    validator: 'number'
+    validator: 'number',
+    rules: []
   },
   smallint: {
-    validator: 'number'
+    validator: 'number',
+    rules: []
   },
   text: {
     validator: 'string',
     textType: 'text',
-    values: ['text', 'mediumtext', 'longtext']
+    values: ['text', 'mediumtext', 'longtext'],
+    rules: []
   },
   string: {
     validator: 'string',
-    maxLength: 255,
-    minLength: 0
+    maxLength: 50,
+    minLength: 0,
+    rules: []
   },
   float: {
-    validator: 'number'
+    validator: 'number',
+    rules: []
   },
   double: {
-    validator: 'number'
+    validator: 'number',
+    rules: []
   },
   boolean: {
-    validator: 'boolean'
-  },
-  date: {
-    validator: 'date'
+    validator: 'boolean',
+    rules: []
   },
   datetime: {
-    validator: 'date'
+    validator: 'date',
+    rules: []
   },
-  time: {
-    validator: 'date'
+  object: {
+    validator: null,
+    rules: []
   },
-  timestamp: {
-    validator: 'timestamp'
-  },
-  object: {},
-  array: {}
+  array: {
+    validator: null,
+    rules: []
+  }
 }
 
+const commonPropertyTypes = ['name', 'type', 'required', 'rules', 'validator', 'ref', 'default']
+
 /**
  * Plugin factory
  *
@@ -116,6 +91,9 @@ const propType = {
  */
 async function factory (pkgName) {
   const me = this
+  const { breakNsPath } = this.app.bajo
+
+  const { find, filter, isString, map, pick, groupBy, isEmpty } = this.app.lib._
 
   /**
    * Dobo Database Framework for {@link https://github.com/ardhi/bajo|Bajo}.
@@ -124,25 +102,40 @@ async function factory (pkgName) {
    *
    * @class
    */
-  class Dobo extends this.app.pluginClass.base {
+  class Dobo extends this.app.baseClass.Base {
     /**
-     * @constant {string}
+     * @constant {string[]}
      * @memberof Dobo
-     * @default 'db'
+     * @default ['count', 'avg', 'min', 'max', 'sum']
      */
-    static alias = 'db'
+    static aggregateTypes = ['count', 'avg', 'min', 'max', 'sum']
 
     /**
      * @constant {string[]}
      * @memberof Dobo
-     * @default ['count', 'avg', 'min', 'max', 'sum']
+     * @default ['string', 'integer', 'smallint']
      */
-    static aggregateTypes = ['count', 'avg', 'min', 'max', 'sum']
+    static idTypes = ['string', 'integer', 'smallint']
+
+    /**
+     * @constant {string[]}
+     * @memberof Dobo
+     * @default ['daily', 'monthly', 'annually']
+     */
+    static histogramTypes = ['daily', 'monthly', 'yearly']
+
+    /**
+     * @constant {TPropertyType}
+     * @memberof Dobo
+     */
+    static propertyType = propertyType
+
     /**
-     * @constant {TPropType}
+     * @constant {string[]}
      * @memberof Dobo
+     * @default ['index', 'unique', 'primary', 'fulltext']
      */
-    static propType = propType
+    static indexTypes = ['index', 'unique', 'primary', 'fulltext']
 
     constructor () {
       super(pkgName, me.app)
@@ -154,32 +147,15 @@ async function factory (pkgName) {
           allowUnknown: true
         },
         default: {
-          property: {
-            text: {
-              textType: 'text'
-            },
-            string: {
-              length: 50
-            }
-          },
           filter: {
             limit: 25,
             maxLimit: 200,
             hardLimit: 10000,
             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: {
-            syncPeriodDur: '1s'
-          }
+          autoSaveDur: '1s'
         },
         applet: {
           confirmation: false
@@ -204,7 +180,38 @@ async function factory (pkgName) {
       /**
        * @type {Object[]}
        */
-      this.schemas = []
+      this.models = []
+    }
+
+    /**
+     * Get allowed property keys by field type
+     *
+     * @param {string} type
+     * @returns {string[]}
+     */
+    getPropertyKeysByType = (type) => {
+      const keys = [...commonPropertyTypes]
+      if (['string'].includes(type)) keys.push('minLength', 'maxLength', 'values')
+      if (['text'].includes(type)) keys.push('textType')
+      if (['smallint', 'integer'].includes(type)) keys.push('autoInc', 'values')
+      if (['float', 'double'].includes(type)) keys.push('values')
+      return keys
+    }
+
+    /**
+     * Get all allowed property keys
+     *
+     * @returns {string[]}
+     */
+
+    getAllPropertyKeys = (driver) => {
+      const { uniq, isEmpty } = this.app.lib._
+      const keys = [...commonPropertyTypes]
+      for (const type in propertyType) {
+        keys.push(...Object.keys(propertyType[type]))
+      }
+      if (driver && !isEmpty(driver.constructor.propertyKeys)) keys.push(...driver.constructor.propertyKeys)
+      return uniq(keys)
     }
 
     /**
@@ -212,31 +219,19 @@ async function factory (pkgName) {
      * - {@link module:Lib.collectDrivers|Collecting all drivers}
      * - {@link module:Lib.collectConnections|Collecting all connections}
      * - {@link module:Lib.collectFeatures|Collecting all features}
-     * - {@link module:Lib.collectSchemas|Collecting all schemas}
+     * - {@link module:Lib.collectModels|Collecting all models}
      * @method
      * @async
      */
     init = async () => {
-      const { buildCollections } = this.app.bajo
+      const { getPluginDataDir } = this.app.bajo
       const { fs } = this.app.lib
-      const checkType = async (item, items) => {
-        const { filter } = this.app.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.ns, container: 'connections', handler: collectConnections, dupChecks: ['name', checkType] })
-      if (this.connections.length === 0) this.log.warn('notFound%s', this.t('connection'))
+      await collectConnections.call(this)
       await collectFeatures.call(this)
-      await collectSchemas.call(this)
+      await collectModels.call(this)
+      const attDir = `${getPluginDataDir('dobo')}/attachment`
+      fs.ensureDirSync(attDir)
     }
 
     /**
@@ -245,239 +240,98 @@ async function factory (pkgName) {
      * @method
      * @async
      * @param {(string|Array)} [conns=all] - Which connections should be run on start
-     * @param {boolean} [noRebuild=false] - Set ```true``` to ALWAYS rebuild model on start. Yes, only set it to ```true``` if you REALLY know what you're doing!!!
+     * @param {boolean} [noRebuild=true] - Set ```false``` to not rebuild model on start. Yes, only set it to ```false``` if you REALLY know what you're doing!!!
      */
     start = async (conns = 'all', noRebuild = true) => {
-      const { importModule, breakNsPath } = this.app.bajo
-      const { find, filter, isString, map } = this.app.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}:/extend/${this.ns}/boot/instantiate.js`)
-        await mod.call(this.app[ns], { connection: c, noRebuild, schemas })
-        this.log.trace('driverInstantiated%s%s', c.driver, c.name)
+      this.log.debug('dbInit')
+      for (const connection of conns) {
+        await connection.connect(noRebuild)
+        this.log.trace('dbInit%s%s%s', connection.driver.plugin.ns, connection.driver.name, connection.name)
       }
-      await memDbStart.call(this)
     }
 
     /**
-     * Pick only fields defined from a record
+     * Get connection by name. It returns the first connection named after "{name}"
      *
-     * @method
-     * @async
-     * @param {Object} [options={}] - Options object
-     * @param {Object} options.record - Record to pick fields from
-     * @param {Array} options.fields - Array of field names to be picked
-     * @param {Object} options.schema - Associated record's schema
-     * @param {Object} [options.hidden=[]] - Additional fields to be hidden in addition the one defined in schema
-     * @param {boolean} [options.forceNoHidden] - Force ALL fields to be picked, thus ignoring hidden fields
-     * @returns {Object}
+     * @param {string} name - Connection name
+     * @param {boolean} [silent] - If ```true``` and connection is not found, it won't throw error
+     * @returns {Driver} Return connection instance or ```undefined``` if silent is ```true```
      */
-    pickRecord = async ({ record, fields, schema = {}, hidden = [], forceNoHidden } = {}) => {
-      const { isArray, pick, clone, isEmpty, omit } = this.app.lib._
-      const { dayjs } = this.app.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)
+    getConnection = (name, silent) => {
+      const conn = find(this.connections, { name })
+      if (!conn && !silent) throw this.error('unknown%s%s', this.t('connection'), name)
+      return conn
     }
 
     /**
-     * Prepare records pagination:
-     * - making sure records limit is obeyed
-     * - making sure page is a positive value
-     * - if skip is given, recalculate limit to use skip instead of page number
-     * - Build sort info
+     * Get driver by name. It returns the first driver named after "{name}"
      *
-     * @method
-     * @async
-     * @param {Object} [filter={}] - Filter object
-     * @param {Object} schema - Model's schema
-     * @param {Object} options - Options
-     * @returns {TRecordPagination}
+     * Also support NsPath format for those who load the same named driver but from different provider/plugin.
+     *
+     * @param {string} name - Driver name
+     * @param {boolean} [silent] - If ```true``` and driver is not found, it won't throw error
+     * @returns {Driver} Returns driver instance or ```undefined``` if silent is ```true```
      */
-    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.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
+    getDriver = (name, silent) => {
+      const { breakNsPath } = this.app.bajo
+      let driver
+      if (!name.includes(':')) {
+        driver = find(this.drivers, { name })
+        if (driver) return driver
+        driver = filter(this.drivers, d => d.plugin.ns === name)
+        if (driver.length === 1) return driver[0]
+        if (!silent) throw this.error('unknown%s%s', this.t('driver'), name)
+        return
       }
-
-      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 }
+      const { ns, path } = breakNsPath(name)
+      driver = find(this.drivers, d => d.name === path && d.plugin.ns === ns)
+      if (!driver && !silent) throw this.error('unknown%s%s', this.t('driver'), name)
+      return driver
     }
 
-    buildMatch = ({ input = '', schema, options }) => {
-      const { isPlainObject, trim } = this.app.lib._
-      if (isPlainObject(input)) return input
-      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
+    /**
+     * Get feature by name. It returns the first driver named after "{name}"
+     *
+     * Also support NsPath format for those who load the same named driver but from different provider/plugin.
+     *
+     * @param {string} - Feature name
+     * @returns {Feature} Return feature instance
+     */
+    getFeature = name => {
+      if (!name.includes(':')) return find(this.features, { name })
+      const { ns, path } = breakNsPath(name)
+      const feat = find(this.features, d => d.name === path && d.plugin.ns === ns)
+      if (!feat) throw this.error('unknown%s%s', this.t('feature'), name)
+      return feat
     }
 
-    buildQuery = ({ filter, schema, options = {} } = {}) => {
-      const { trim, find, isString, isPlainObject } = this.app.lib._
-      let query = {}
-      if (isString(filter.query)) {
-        try {
-          filter.query = trim(filter.query)
-          filter.orgQuery = filter.query
-          if (trim(filter.query).startsWith('{')) query = JSON.parse(filter.query)
-          else if (filter.query.includes(':')) query = nql(filter.query).parse()
-          else {
-            const fields = schema.sortables.filter(f => {
-              const field = find(schema.properties, { name: f, type: 'string' })
-              return !!field
-            })
-            const parts = fields.map(f => {
-              if (filter.query[0] === '*') return `${f}:~$'${filter.query.replaceAll('*', '')}'`
-              if (filter.query[filter.length - 1] === '*') return `${f}:~^'${filter.query.replaceAll('*', '')}'`
-              return `${f}:~'${filter.query.replaceAll('*', '')}'`
-            })
-            if (parts.length === 1) query = nql(parts[0]).parse()
-            else if (parts.length > 1) query = nql(parts.join(',')).parse()
-          }
-        } catch (err) {
-          this.error('invalidQuery', { orgMessage: err.message })
-        }
-      } else if (isPlainObject(filter.query)) query = filter.query
-      return this.sanitizeQuery(query, schema)
+    /**
+     * Get model by name
+     *
+     * @param {string} name - Model name
+     * @param {boolean} [silent] - If ```true``` and model is not found, it won't throw error
+     * @retuns {Model} Returns model instance or ```undefined``` if silent is ```true```
+     */
+    getModel = (name, silent) => {
+      const { pascalCase } = this.app.lib.aneka
+      let model = find(this.models, { name })
+      if (!model) model = find(this.models, { name: pascalCase(name) })
+      if (!model && !silent) throw this.error('unknown%s%s', this.t('model'), name)
+      return model
     }
 
-    sanitizeQuery = (query, schema, parent) => {
-      const { cloneDeep, isPlainObject, isArray, find } = this.app.lib._
-      const { isSet } = this.app.lib.aneka
-      const { dayjs } = this.app.lib
-      const obj = cloneDeep(query)
-      const keys = Object.keys(obj)
-      const sanitize = (key, val, p) => {
-        if (!isSet(val)) return val
-        const prop = find(schema.properties, { name: key.startsWith('$') ? p : key })
-        if (!prop) return val
-        if (['datetime', 'date', 'time'].includes(prop.type)) {
-          const dt = dayjs(val)
-          return dt.isValid() ? dt.toDate() : val
-        } else if (['smallint', 'integer'].includes(prop.type)) return parseInt(val) || val
-        else if (['float', 'double'].includes(prop.type)) return parseFloat(val) || val
-        else if (['boolean'].includes(prop.type)) return !!val
-        return val
-      }
-      keys.forEach(k => {
-        const v = obj[k]
-        if (isPlainObject(v)) obj[k] = this.sanitizeQuery(v, schema, k)
-        else if (isArray(v)) {
-          v.forEach((i, idx) => {
-            if (isPlainObject(i)) obj[k][idx] = this.sanitizeQuery(i, schema, k)
-          })
-        } else obj[k] = sanitize(k, v, parent)
-      })
-      return obj
+    /**
+     * Get all models that bound to connection ```name```
+     *
+     * @param {string} name - Connection name
+     * @returns {Array}
+     */
+    getModelsByConnection = name => {
+      const conn = this.getConnection(name)
+      return this.models.filter(s => s.connection.name === conn.name)
     }
 
     validationErrorMessage = (err) => {
@@ -491,81 +345,140 @@ async function factory (pkgName) {
       return text
     }
 
-    getConnection = (name) => {
-      const { find } = this.app.lib._
-      return find(this.connections, { name })
+    /**
+     * Sanitize value as a date/time value. Parse/format string using {@link https://day.js.org/docs/en/display/format|dayjs format}
+     *
+     * @method
+     * @memberof Dobo
+     * @param {(number|string)} value - Value to sanitize
+     * @param {Object} [options={}] - Options object
+     * @param {boolean} [options.silent=true] - If ```true``` (default) and value isn't valid, returns empty
+     * @param {string} [options.inputFormat] - If provided, parse value using this option
+     * @param {string} [options.outputFormat] - If not provided or ```native```, returns Javascript Date. Otherwise returns formatted date/time string
+     * @returns {(string|Date)}
+     */
+    sanitizeDate = (value, { inputFormat, outputFormat, silent = true } = {}) => {
+      const { dayjs } = this.app.lib
+      if (value === 0) return null
+      if (!outputFormat) outputFormat = inputFormat
+      const dt = dayjs(value, inputFormat)
+      if (!dt.isValid()) {
+        if (silent) return null
+        throw this.error('invalidDate')
+      }
+      if (outputFormat === 'native' || !outputFormat) return dt.toDate()
+      return dt.format(outputFormat)
     }
 
-    getInfo = (name) => {
-      const { breakNsPath } = this.app.bajo
-      const { find, map, isEmpty } = this.app.lib._
-      const schema = this.getSchema(name)
-      const conn = this.getConnection(schema.connection)
-      let { ns, path: type } = breakNsPath(conn.type)
-      if (isEmpty(type)) type = 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 }
+    sanitizeFloat = (value, { strict = false } = {}) => {
+      const { isNumber } = this.app.lib._
+      if (isNumber(value)) return value
+      if (strict) return Number(value)
+      return parseFloat(value) || null
     }
 
-    getSchema = (input, cloned = true) => {
-      const { find, isPlainObject, cloneDeep } = this.app.lib._
-      const { pascalCase } = this.app.lib.aneka
-      let name = isPlainObject(input) ? input.name : input
-      name = pascalCase(name)
-      const schema = find(this.schemas, { name })
-      if (!schema) throw this.error('unknownModelSchema%s', name)
-      return cloned ? cloneDeep(schema) : schema
+    sanitizeInt = (value, { strict = false } = {}) => {
+      const { isNumber } = this.app.lib._
+      if (isNumber(value)) return value
+      if (strict) return Number(value)
+      return parseInt(value) || null
     }
 
-    getField = (name, model) => {
-      const { getInfo } = this.app.dobo
-      const { find } = this.app.lib._
-      const { schema } = getInfo(model)
+    sanitizeObject = (value) => {
+      const { isString } = this.app.lib._
+      let result = null
+      if (isString(value)) {
+        try {
+          result = JSON.parse(value)
+        } catch (err) {}
+      } else {
+        try {
+          result = JSON.parse(JSON.stringify(value))
+        } catch (err) {}
+      }
+      return result
+    }
 
-      return find(schema.properties, { name })
+    sanitizeBoolean = (value) => {
+      return value === null ? null : (['true', true].includes(value))
     }
 
-    hasField = (name, model) => {
-      return !!this.getField(name, model)
+    sanitizeTimestamp = (value) => {
+      const { isNumber } = this.app.lib._
+      const { dayjs } = this.app.lib
+      if (!isNumber(value)) return -1
+      const dt = dayjs.unix(value)
+      return dt.isValid() ? dt.unix() : -1
     }
 
-    getMemdbStorage = (name, fields = []) => {
-      const { map, pick } = this.app.lib._
-      const all = this.memDb.storage[name] ?? []
-      if (fields.length === 0) return all
-      return map(all, item => pick(item, fields))
+    sanitizeString = (value) => {
+      return value + ''
     }
 
-    listAttachments = async ({ model, id = '*', field = '*', file = '*' } = {}, { uriEncoded = true } = {}) => {
-      const { map, kebabCase } = this.app.lib._
-      const { pascalCase } = this.app.lib.aneka
-      const { importPkg, getPluginDataDir } = this.app.bajo
-      const mime = await importPkg('waibu:mime')
-      const { fastGlob } = this.app.lib
-      const root = `${getPluginDataDir('dobo')}/attachment`
-      model = pascalCase(model)
-      let pattern = `${root}/${model}/${id}/${field}/${file}`
-      if (uriEncoded) pattern = pattern.split('/').map(p => decodeURI(p)).join('/')
-      return map(await fastGlob(pattern), f => {
-        const mimeType = mime.getType(path.extname(f)) ?? ''
-        const fullPath = f.replace(root, '')
-        const row = {
-          file: f,
-          fileName: path.basename(fullPath),
-          fullPath,
-          mimeType,
-          params: { model, id, field, file }
-        }
-        if (this.app.waibuMpa) {
-          const { routePath } = this.app.waibu
-          const [, _model, _id, _field, _file] = fullPath.split('/')
-          row.url = routePath(`dobo:/attachment/${kebabCase(_model)}/${_id}/${_field}/${_file}`)
-        }
-        return row
-      })
+    _calcStats = (items, field, aggregates) => {
+      const { generateId, isSet } = this.app.lib.aneka
+      const result = { id: generateId, count: 0, avg: null, min: null, max: null }
+      let sum = 0
+      for (const item of items) {
+        const value = Number(item[field]) ?? 0
+        if (aggregates.includes('count')) result.count++
+        if (aggregates.includes('avg')) sum = sum + value
+        if (aggregates.includes('min') && (!isSet(result.min) || value < result.min)) result.min = value
+        if (aggregates.includes('max') && (!isSet(result.max) || value > result.max)) result.max = value
+      }
+      result.avg = sum / items.length
+      return result
+    }
+
+    calcAggregate = ({ data = [], group = '', field = '', aggregates = ['count'] } = {}) => {
+      this.checkAggregateParams({ group, field, aggregates })
+      const { pick, groupBy } = this.app.lib._
+      const grouped = groupBy(data, group)
+      const all = []
+      for (const key in grouped) {
+        const items = grouped[key]
+        const result = this._calcStats(items, field, aggregates)
+        result[group] = key
+        all.push(pick(result, ['id', group, ...aggregates]))
+      }
+      return all
+    }
+
+    calcHistogram = ({ data = [], type = '', group = '', field = '', aggregates = ['count'] } = {}) => {
+      this.checkHistogramParams({ group, field, type, aggregates })
+      const { dayjs } = this.app.lib
+      const pattern = { daily: ['YYYY-MM-DD', 'date'], monthly: ['YYYY-MM', 'month'], yearly: ['YYYY', 'year'] }
+      for (const d of data) {
+        d._group = dayjs(d[group]).format(pattern[type][0])
+      }
+      const grouped = groupBy(data, '_group')
+      const all = []
+      for (const key in grouped) {
+        const items = grouped[key]
+        const result = this._calcStats(items, field, aggregates)
+        const title = pattern[type][1]
+        result[title] = key
+        all.push(pick(result, ['id', title, ...aggregates]))
+      }
+      return all
+    }
+
+    checkAggregateParams = (params = {}) => {
+      let { group, field, aggregates } = params
+      if (isString(aggregates)) aggregates = [aggregates]
+      params.aggregates = aggregates
+      if (isEmpty(group)) throw this.error('fieldGroupMissing')
+      if (isEmpty(field)) throw this.error('fieldCalcMissing')
+      for (const agg of aggregates) {
+        if (!this.constructor.aggregateTypes.includes(agg)) throw this.error('unsupportedAggregateType%s', agg)
+      }
+    }
+
+    checkHistogramParams = (params = {}) => {
+      this.checkAggregateParams(params)
+      const { type } = params
+      if (isEmpty(type)) throw this.error('histogramTypeMissing')
+      if (!this.constructor.histogramTypes.includes(type)) throw this.error('unsupportedHistogramType%s', type)
     }
   }