dobo 2.0.0 → 2.2.0

package/lib/collect-connections.js

@@ -1,25 +1,64 @@
-async function defSanitizer (item) {
-  return item
-}
+import connectionFactory from './factory/connection.js'
+
+/**
+ * Object to be passed as connection info in dobo config object
+ *
+ * @typedef TConnectionInfo
+ * @memberof module:Lib
+ * @property {string} name - Must be unique along all connections. Required
+ * @property {string} driver - Driver to use. If not in ```TNsPath``` format, it will be autodetected. Required
+ * @property {string} [host]
+ * @property {number} [port]
+ * @property {string} [username]
+ * @property {string} [password]
+ * @property {string} database - Database name. Required
+ * @property {string[]} [models] - List of models forced to use this connection
+ * @property {Object} [options] - Options specific to the driver
+ */
+
+/**
+ * Collect all database connections from {@tutorial config}.
+ *
+ * @name collectConnections
+ * @memberof module:Lib
+ * @async
+ * @see Dobo#init
+ * @param {Object} [options={}]
+ * @param {Object} [options.item={}]
+ * @returns {Object}
+ */
+async function collectConnections () {
+  const { buildCollections } = this.app.bajo
+  const { pullAt } = this.app.lib._
+  const { filterIndex } = this.app.lib.aneka
+  const DoboConnection = await connectionFactory.call(this)
 
-async function collectConnections ({ item, index, options }) {
-  const conn = item
-  const { importModule, breakNsPath } = this.app.bajo
-  const { has, find, isEmpty } = this.lib._
-  if (!has(conn, 'type')) this.fatal('mustValidDbType')
-  let { ns, path: type } = breakNsPath(conn.type)
-  if (isEmpty(type)) type = conn.type
-  const driver = find(this.drivers, { ns, type })
-  if (!driver) this.fatal('unsupportedDbType%s', conn.type)
-  let file = `${ns}:/extend/${this.name}/lib/${type}/conn-sanitizer.js`
-  if (conn.type === 'dobo:memory') file = `${ns}:/lib/mem-db/conn-sanitizer.js`
-  if (driver.provider) file = `${driver.provider}:/extend/${ns}/lib/${type}/conn-sanitizer.js`
-  let sanitizer = await importModule(file)
-  if (!sanitizer) sanitizer = defSanitizer
-  const result = await sanitizer.call(this, conn)
-  result.proxy = result.proxy ?? false
-  result.driver = driver.driver
-  return result
+  async function handler ({ item }) {
+    const { has } = this.app.lib._
+    if (!has(item, 'driver')) this.fatal('unknownDbDriver%s')
+    let driver
+    try {
+      driver = this.getDriver(item.driver, true)
+      if (!driver) throw new Error()
+    } catch (err) {
+      this.fatal('unknownDbDriver%s', item.driver)
+    }
+    await driver.sanitizeConnection(item)
+    const conn = new DoboConnection(this, item)
+    conn.driver = driver
+    return conn
+  }
+  const memIndexes = filterIndex(this.config.connections, current => current.driver === 'dobo:memory' || current.name === 'memory')
+  const models = memIndexes.map(idx => [...(this.config.connections[idx].models ?? [])])
+  pullAt(this.config.connections, memIndexes)
+  this.config.connections.unshift({
+    driver: 'dobo:memory',
+    name: 'memory',
+    models
+  })
+  this.connections = await buildCollections({ ns: this.ns, container: 'connections', handler, dupChecks: ['name'] })
+  const defConn = this.connections.find(conn => conn.name === 'default')
+  if (!defConn) this.log.warn('noDefaultConnection')
 }
 
 export default collectConnections

package/lib/collect-drivers.js

@@ -1,41 +1,35 @@
+import path from 'path'
+import driverFactory from './factory/driver.js'
+
+/**
+ * Collect all database drivers from loaded plugins
+ *
+ * @name collectDrivers
+ * @memberof module:Lib
+ * @async
+ * @see Dobo#init
+ */
 async function collectDrivers () {
-  const { eachPlugins, readConfig, runHook } = this.app.bajo
-  const { isString, find, pick, merge, cloneDeep } = this.lib._
+  const { eachPlugins, runHook } = this.app.bajo
+  const { importModule } = this.app.bajo
+  const { camelCase, isFunction } = this.app.lib._
+  const DoboDriver = await driverFactory.call(this)
+
+  this.log.trace('collecting%s', this.t('driver'))
   const me = this
-  me.drivers = []
-  // built-in memory driver
-  me.drivers.push({
-    type: 'memory',
-    ns: me.name,
-    driver: 'memory',
-    idField: merge(cloneDeep(me.config.default.idField), { name: 'id' })
-  })
-  // others
-  await runHook(`${this.name}:beforeCollectDrivers`)
+  await runHook(`${this.ns}:beforeCollectDrivers`)
   await eachPlugins(async function ({ file }) {
-    const { name: ns } = this
-    const info = await readConfig(file, { ns })
-    if (!info.type) this.fatal('driverMustProvideDbType')
-    if (!info.driver) this.fatal('driverMustHaveName')
-    if (isString(info.type)) info.type = [info.type]
-    if (!info.idField) info.idField = cloneDeep(me.config.default.idField)
-    info.idField.name = 'id'
-    for (const t of info.type) {
-      const [type, provider] = t.split('@')
-      const exists = find(me.drivers, { type, ns })
-      if (exists) this.fatal('dbTypeAlreadySupportedByDriver%s%s', type, info.driver)
-      const driver = pick(find(me.app[ns].drivers, { name: type }) ?? {}, ['dialect', 'idField', 'lowerCaseModel', 'returning'])
-      const ext = {
-        type,
-        ns,
-        provider,
-        driver: info.driver,
-        idField: info.idField
-      }
-      me.drivers.push(merge(ext, driver))
-    }
-  }, { glob: 'boot/driver.*', prefix: this.name })
-  await runHook(`${this.name}:afterCollectDrivers`)
+    const name = camelCase(path.basename(file, '.js'))
+    const factory = await importModule(file)
+    if (!isFunction(factory)) this.fatal('invalidDriverClassFactory%s%s', this.ns, name)
+    const Cls = await factory.call(this)
+    const instance = new Cls(this, name)
+    if (!(instance instanceof DoboDriver)) this.fatal('invalidDriverClass%s%s', this.ns, name)
+    me.drivers.push(instance)
+    me.log.trace('- %s', name)
+  }, { glob: 'driver/*.js', prefix: this.ns })
+  await runHook(`${this.ns}:afterCollectDrivers`)
+  this.log.debug('collected%s%d', this.t('driver'), this.drivers.length)
 }
 
 export default collectDrivers

package/lib/collect-features.js

@@ -0,0 +1,40 @@
+import path from 'path'
+import featureFactory from './factory/feature.js'
+
+/**
+ * Object to be passed as feature input in ```{model}.features```
+ *
+ * @typedef TFeatureInput
+ * @memberof module:Lib
+ * @property {string} name - Accept ```TNsPath```. If standard string is given, ```ns``` is set to ```dobo```
+ * @property {any} [param]
+ */
+
+/**
+ * Collect all database features from all loaded plugins
+ *
+ * @name collectFeatures
+ * @memberof module:Lib
+ * @async
+ * @see Dobo#init
+ */
+async function collectFeature () {
+  const { eachPlugins } = this.app.bajo
+  const DoboFeature = await featureFactory.call(this)
+
+  this.log.trace('collecting%s', this.t('feature'))
+  const me = this
+  await eachPlugins(async function ({ file }) {
+    const { importModule } = this.app.bajo
+    const { camelCase, isFunction } = this.app.lib._
+
+    const name = camelCase(path.basename(file, '.js'))
+    const handler = await importModule(file)
+    if (!isFunction(handler)) this.fatal('invalidFeatureHandler%s%s', this.ns, name)
+    me.features.push(new DoboFeature(this, { name, handler }))
+    me.log.trace('- %s:%s', this.ns, name)
+  }, { glob: 'feature/*.js', prefix: this.ns })
+  this.log.debug('collected%s%d', this.t('feature'), this.features.length)
+}
+
+export default collectFeature

package/lib/collect-models.js

@@ -0,0 +1,319 @@
+import path from 'path'
+import modelFactory from './factory/model.js'
+
+/**
+ * Sanitize one single property of a model
+ *
+ * @param {Object} model - Loaded model
+ * @param {Object} prop - Property to check
+ * @param {Array} [indexes] - Container array to fill up found index
+ */
+async function sanitizeProp (model, prop, indexes) {
+  const { isEmpty, isString, keys, pick } = this.app.lib._
+  const allPropKeys = this.getAllPropertyKeys(model.connection.driver)
+  const propType = this.constructor.propertyType
+  if (isString(prop)) {
+    let [name, type, maxLength, idx, required] = prop.split(',').map(m => m.trim())
+    if (isEmpty(type)) type = 'string'
+    maxLength = isEmpty(maxLength) ? propType.string.maxLength : parseInt(maxLength)
+    prop = { name, type, maxLength }
+    if (!isEmpty(idx)) prop.index = idx
+    prop.required = required === 'true'
+  }
+  prop.type = prop.type ?? 'string'
+  if (prop.index) {
+    if (prop.index === true || prop.index === 'true') prop.index = 'index'
+    const [idx, idxName] = prop.index.split(':')
+    const index = { name: idxName ?? `${model.collName}_${prop.name}_${idx}`, fields: [prop.name], type: idx }
+    indexes.push(index)
+  }
+  if (prop.hidden) model.hidden.push(prop.name)
+  if (keys(propType).includes(prop.type)) model.properties.push(pick(prop, allPropKeys))
+  else {
+    const feature = this.getFeature(prop.type)
+    if (!feature) this.fatal('unknownPropType%s%s', prop.type, model.name)
+    await applyFeature.call(this, model, feature, { name: prop.name }, indexes)
+  }
+}
+
+/**
+ * Collect all properties it can be found on model
+ *
+ * @param {Object} model - Model
+ * @param {Array} [inputs] - Array of properties
+ * @param {Array} [indexes] - Container array to fill up found index
+ */
+async function findAllProps (model, inputs = [], indexes = [], isExtender) {
+  const { isPlainObject, cloneDeep } = this.app.lib._
+  const isIdProp = inputs.find(p => {
+    return isPlainObject(p) ? p.name === 'id' : p.startsWith('id,')
+  })
+  if (!isExtender && !isIdProp) {
+    const idField = cloneDeep(model.connection.driver.idField)
+    idField.name = 'id'
+    inputs.unshift(idField)
+  }
+  for (const prop of inputs) {
+    await sanitizeProp.call(this, model, prop, indexes)
+  }
+}
+
+/**
+ * Apply each feature found
+ * @param {Object} model - Model
+ * @param {Object} feature - Feature to apply
+ * @param {Object} options - Options to the feature
+ * @returns {Array} New properties found in feature
+ */
+async function applyFeature (model, feature, options, indexes) {
+  const { isArray } = this.app.lib._
+  const item = await feature.handler(options)
+  if (item.rules) model.rules.push(...item.rules)
+  if (!isArray(item.properties)) item.properties = [item.properties]
+  for (const prop of item.properties) {
+    await sanitizeProp.call(this, model, prop, indexes)
+  }
+  if (item.hooks) {
+    item.hooks = item.hooks.map(hook => {
+      hook.level = hook.level ?? 999
+      return hook
+    })
+    model.hooks.push(...item.hooks)
+  }
+}
+
+/**
+ * Collect all features it can be found on model
+ *
+ * @param {Object} model - Model
+ * @param {Array} [inputs] - Array of properties
+ */
+async function findAllFeats (model, inputs = [], indexes = []) {
+  const { isString, omit } = this.app.lib._
+  for (let feat of inputs) {
+    if (isString(feat)) feat = { name: feat }
+    const featName = feat.name.indexOf(':') === -1 ? `dobo:${feat.name}` : feat.name
+    const feature = this.app.dobo.getFeature(featName)
+    if (!feature) this.fatal('invalidFeature%s%s', model.name, featName)
+    await applyFeature.call(this, model, feature, omit(feat, 'name'), indexes)
+  }
+}
+
+/**
+ * Collect all indexes it can be found on model
+ *
+ * @param {Object} model - Model
+ * @param {Array} [inputs] - Array of properties
+ */
+async function findAllIndexes (model, inputs = []) {
+  const indexes = []
+  for (const index of inputs) {
+    index.type = index.type ?? 'index'
+    index.fields = index.fields ?? []
+    if (!index.name) index.name = `${model.name}_${index.fields.join('_')}_${index.type}`
+    indexes.push(index)
+  }
+  model.indexes = indexes
+}
+
+/**
+ * Sanitize any reference/relationship found in properties
+ *
+ * @param {Object} model - Model
+ * @param {Array} [models] - All model match agaist. Defaults to ```dobo.models```
+ */
+export async function sanitizeRef (model, models, fatal) {
+  const { find, isString, pullAt } = this.app.lib._
+  if (!models) models = this.models
+  for (const prop of model.properties) {
+    const ignored = []
+    for (const key in prop.ref ?? {}) {
+      let ref = prop.ref[key]
+      if (isString(ref)) {
+        ref = { propName: ref }
+      }
+      ref.type = ref.type ?? '1:1'
+      const rModel = find(models, { name: ref.model })
+      if (!rModel) {
+        if (fatal) this.fatal('unknownModelForRef%s%s%s', ref.model, model.name, prop.name)
+        else ignored.push(ref.model)
+      }
+      const rProp = find(rModel.properties, { name: ref.propName })
+      if (!rProp) {
+        if (fatal) this.fatal('unknownPropForRef%s%s%s%s', ref.model, ref.propName, model.name, prop.name)
+        else ignored.push(ref.model)
+      }
+      ref.fields = ref.fields ?? '*'
+      if (['*', 'all'].includes(ref.fields)) ref.fields = rModel.properties.map(p => p.name)
+      if (ref.fields.length > 0 && !ref.fields.includes('id')) ref.fields.unshift('id')
+      const removed = []
+      for (const idx in ref.fields) {
+        const p = find(rModel.properties, { name: ref.fields[idx] })
+        if (!p) removed.push(ref.fields[idx])
+      }
+      pullAt(ref.fields, removed)
+      prop.ref[key] = ref
+    }
+    for (const key of ignored) {
+      delete prop.ref[key]
+    }
+  }
+}
+
+/**
+ * Sanitize all but reference, because a reference needs all models to be available first
+ *
+ * @param {Object} model - Model
+ */
+export async function sanitizeAll (model) {
+  const { runHook } = this.app.bajo
+  const { pick, keys, map, uniq, camelCase, filter } = this.app.lib._
+  const { defaultsDeep } = this.app.lib.aneka
+  const allPropNames = uniq(map(model.properties, 'name'))
+  const propType = this.constructor.propertyType
+  const indexTypes = this.constructor.indexTypes
+
+  await runHook(`dobo.${camelCase(model.name)}:beforeSanitizeModel`, model)
+  // properties
+  for (const idx in model.properties) {
+    let prop = model.properties[idx]
+    const def = propType[prop.type]
+    prop = pick(defaultsDeep(prop, def), this.getPropertyKeysByType(prop.type))
+    if (!keys(propType).includes(prop.type)) this.fatal('unknownPropType%s%s', `${prop.name}.${def.name}`, prop.type)
+    if (prop.type === 'string') {
+      prop.minLength = parseInt(prop.minLength) ?? 0
+      prop.maxLength = parseInt(prop.maxLength) ?? 255
+      if (prop.minLength > 0) prop.required = true
+      if (prop.minLength === 0) delete prop.minLength
+    }
+    model.properties[idx] = prop
+  }
+  // indexes
+  for (const index of model.indexes) {
+    if (!indexTypes.includes(index.type)) this.fatal('unknownIndexType%s%s', index.type, model.name)
+    for (const field of index.fields) {
+      if (!allPropNames.includes(field)) this.fatal('unknownPropNameOnIndex%s%s', field, model.name)
+    }
+  }
+  await runHook(`dobo.${camelCase(model.name)}:afterSanitizeModel`, model)
+  // sortables
+  model.sortables = []
+  for (const index of model.indexes) {
+    model.sortables.push(...index.fields)
+  }
+  model.hidden = filter(uniq(model.hidden), prop => allPropNames.includes(prop))
+}
+
+/**
+ * Create schema for model
+ *
+ * @param {Object} item - Source item
+ * @returns {Object} Sanitized model
+ */
+async function createSchema (item) {
+  const { readConfig } = this.app.bajo
+  const { fastGlob } = this.app.lib
+  const { find, isPlainObject, orderBy } = this.app.lib._
+  const { mergeObjectsByKey } = this.app.lib.aneka
+  if (item.file && !item.base) item.base = path.basename(item.file, path.extname(item.file))
+  item.attachment = item.attachment ?? true
+  const feats = item.features ?? []
+  const props = item.properties ?? []
+  const indexes = item.indexes ?? []
+  item.features = []
+  item.properties = []
+  item.indexes = []
+  item.hidden = item.hidden ?? []
+  item.rules = item.rules ?? []
+  item.buildLevel = item.buildLevel ?? 999
+  const conn = item.connection ?? 'default'
+  item.connection = null
+  item.hooks = item.hooks ?? []
+  item.disabled = item.disabled ?? []
+  if (item.disabled === 'all') item.disabled = ['find', 'get', 'create', 'update', 'remove']
+  else if (item.disabled === 'readonly') item.disabled = ['create', 'update', 'remove']
+  // Is there any overwritten connection?
+  const newConn = find(this.connections, c => c.options.models.includes(item.name))
+  if (newConn) item.connection = newConn
+  else {
+    item.connection = this.getConnection(conn, true)
+    if (!item.connection && conn === 'default') item.connection = this.getConnection('memory')
+  }
+  if (!item.connection) this.fatal('unknownConn%s%s', conn, item.name)
+  await findAllProps.call(this, item, props, indexes)
+  await findAllFeats.call(this, item, feats, indexes)
+  await findAllIndexes.call(this, item, indexes)
+  // item extender
+  if (item.base) {
+    for (const ns of this.app.getAllNs()) {
+      const plugin = this.app[ns]
+      const glob = `${plugin.dir.pkg}/extend/dobo/extend/${item.ns}/item/${item.base}.*`
+      const files = await fastGlob(glob)
+      for (const file of files) {
+        const extender = await readConfig(file, { ns: plugin.ns, ignoreError: true })
+        if (!isPlainObject(extender)) this.plugin.fatal('invalidModelExtender%s%s', ns, item.name)
+        await findAllProps.call(this, item, extender.properties ?? [], indexes, true)
+        await findAllFeats.call(this, item, extender.features ?? [], indexes, true)
+        await findAllIndexes.call(this, item, extender.indexes ?? [], true)
+      }
+    }
+  }
+  for (const key of ['properties', 'indexes']) {
+    item[key] = mergeObjectsByKey(item[key], 'name')
+  }
+  item.hooks = orderBy(item.hooks, ['name', 'level'])
+  delete item.features
+  delete item.base
+  await sanitizeAll.call(this, item)
+  return item
+}
+
+/**
+ * Collect all models from loaded plugins and create the models
+ *
+ * @name collectModels
+ * @memberof module:lib
+ * @async
+ * @see Dobo#init
+ */
+async function collectModels () {
+  const { eachPlugins } = this.app.bajo
+  const { orderBy, has } = this.app.lib._
+  const DoboModel = await modelFactory.call(this)
+
+  this.log.trace('collecting%s', this.t('model'))
+  const me = this
+  let schemas = []
+  await eachPlugins(async function ({ file }) {
+    const { readConfig } = this.app.bajo
+    const { pascalCase } = this.app.lib.aneka
+    const { isPlainObject } = this.app.lib._
+
+    const base = path.basename(file, path.extname(file))
+    const defName = pascalCase(`${this.alias} ${base}`)
+    const item = await readConfig(file, { ns: this.ns, ignoreError: true })
+    if (!isPlainObject(item)) me.fatal('invalidModel%s', defName)
+    item.name = item.name ?? defName
+    item.collName = item.collName ?? item.name
+    item.file = file
+    const schema = await createSchema.call(me, item)
+    schema.ns = this.ns
+    schemas.push(item)
+  }, { glob: 'model/*.*', prefix: this.ns })
+  schemas = orderBy(schemas, ['buildLevel', 'name'])
+  for (const schema of schemas) {
+    const plugin = this.app[schema.ns]
+    delete schema.ns
+    await sanitizeRef.call(this, schema, schemas, true)
+    const idProp = schema.properties.find(p => p.name === 'id')
+    if (!this.constructor.idTypes.includes(idProp.type)) this.fatal('invalidIdType%s%s', schema.name, this.constructor.idTypes.join(', '))
+    if (idProp.type === 'string' && !has(idProp, 'maxLength')) idProp.maxLength = 50
+    // schema.properties = without(schema.properties, undefined)
+    const model = new DoboModel(plugin, schema)
+    me.models.push(model)
+    me.log.trace('- %s', model.name)
+  }
+  this.log.debug('collected%s%d', this.t('model'), this.models.length)
+}
+
+export default collectModels

package/lib/factory/action.js

@@ -0,0 +1,161 @@
+const methods = {
+  createRecord: ['body'],
+  updateRecord: ['id', 'body'],
+  upsertRecord: ['body'],
+  removeRecord: ['id'],
+  getRecord: ['id'],
+  findRecord: ['filter'],
+  findOneRecord: ['filter'],
+  findAllRecord: ['filter'],
+  findAllRecords: ['filter'],
+  countRecord: ['params'],
+  createAggregate: ['params'],
+  createHistogram: ['params'],
+  createAttachment: ['id'],
+  findAttachment: ['id'],
+  getAttachment: ['id', 'fieldName', 'file'],
+  listAttachment: ['params'],
+  removeAttachment: ['id', 'fieldName', 'file'],
+  updateAttachment: ['id']
+}
+
+const options = {
+  truncateString: true,
+  noResult: true,
+  noBodySanitizer: true,
+  noResultSanitizer: true,
+  noValidation: true,
+  dataOnly: true,
+  noHook: true,
+  noModelHook: true,
+  extFields: [],
+  fields: [],
+  noFlash: true,
+  hidden: [],
+  refs: [],
+  types: [],
+  type: undefined,
+  group: undefined,
+  aggregates: [],
+  field: undefined,
+  queryHandler: undefined,
+  count: true,
+  noCache: true,
+  partial: true,
+  // attachment
+  mimeType: true,
+  fullPath: true,
+  stats: true,
+  dirOnly: true,
+  setField: undefined,
+  setFile: undefined,
+  source: undefined,
+  uriEncoded: true
+}
+
+async function actionFactory () {
+  const { Tools } = this.app.baseClass
+
+  /**
+   * Action class enables you to call model's method with all parameters and options in chainable methods
+   * in addition of the normall call. Examples:
+   *
+   * ```javascript
+   * // method 1:
+   * const result = await model.action().getRecord('rec-id').noHook().dataOnly(false).run()
+   * // method 2:
+   * const result = await model.action('getRecord').id('rec-id').noHook().dataOnly(false).run()
+   * // method 3:
+   * const result = await model.action('getRecord', 'rec-id').noHook().dataOnly(false).run()
+   * // method 4:
+   * const action = await model.getRecord() // Important: no parameter passed
+   * const result = action.id('rec-id').noHook().dataOnly(false).run()
+   * // Instead of chaining options as methods, you can also pass options object to the run() method
+   * const result = await model.action('getRecord', 'rec-id').run({ noHook: true, dataOnly: false })
+   * ```
+   *
+   * @class
+   */
+  class DoboAction extends Tools {
+    constructor (model, name, ...args) {
+      super(model.plugin)
+      this.model = model
+      this.name = name
+      this._options = {}
+      if (name) this._setArgs(name, args)
+      // create methods
+      for (const method in methods) {
+        this[method] = (...args) => {
+          this.name = method
+          this._setArgs(method, args)
+          this._options = {}
+          return this
+        }
+      }
+      // create options builder methods
+      for (const option in options) {
+        this[option] = (value) => {
+          this._options[option] = value ?? options[option]
+          return this
+        }
+      }
+    }
+
+    _setArgs = (method, args) => {
+      if (args.length === 0) return
+      for (const idx in methods[method]) {
+        this['_' + methods[method][idx]] = args[idx]
+      }
+    }
+
+    id = value => {
+      this._id = value
+      return this
+    }
+
+    body = value => {
+      this._body = value
+      return this
+    }
+
+    filter = value => {
+      this._filter = value
+      return this
+    }
+
+    fieldName = value => {
+      this._fieldName = value
+      return this
+    }
+
+    file = value => {
+      this._file = value
+      return this
+    }
+
+    options = (value = {}) => {
+      for (const k in value) {
+        this._options[k] = value
+      }
+      return this
+    }
+
+    run = async (value = {}) => {
+      this.options(value)
+      const args = methods[this.name].map(item => this['_' + item])
+      args.push(this._options)
+      return await this.model[this.name](...args)
+    }
+
+    dispose () {
+      super.dispose()
+      this.model = null
+      this._options = null
+    }
+  }
+
+  this.app.baseClass.DoboAction = DoboAction
+  return DoboAction
+}
+
+export default actionFactory