dobo 1.1.0 → 1.1.2

package/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._
+  const { cloneDeep, camelCase, omit } = this.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/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._
+  const { cloneDeep, camelCase, omit } = this.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/plugin/method/record/update.js

@@ -8,7 +8,8 @@ import singleRelRows from '../../../lib/single-rel-rows.js'
 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._
+  const { forOwn, find, cloneDeep, camelCase, omit, get } = this.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/plugin/method/record/upsert.js

@@ -1,8 +1,9 @@
 async function upsert (name, input, opts = {}) {
   const { generateId } = this.app.bajo
-  const { find } = this.app.bajo.lib._
-  const { cloneDeep, omit } = this.app.bajo.lib._
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
+  const { find } = this.lib._
+  const { cloneDeep, omit, merge } = this.lib._
+  const { query, omitOnUpdate = [], omitOnCreate = [] } = opts
+  const options = cloneDeep(omit(opts, ['req', 'reply', 'query', 'omitOnUpdate', 'omitOnCreate']))
   options.req = opts.req
   options.reply = opts.reply
   options.dataOnly = options.dataOnly ?? true
@@ -13,9 +14,22 @@ async function upsert (name, input, opts = {}) {
   if (idField.type === 'string') id = input.id ?? generateId()
   else if (idField.type === 'integer') id = input.id ?? generateId('int')
   id = this.sanitizeId(id, schema)
-  const old = await this.recordGet(name, id, { thrownNotFound: false, dataOnly: true, noHook: true, noCache: true, force: true, hidden: options.hidden, forceNoHidden: options.forceNoHidden })
-  if (old) return await this.recordUpdate(name, id, input, options)
-  return await this.recordCreate(name, input, options)
+  let old
+  let body
+  const o = { dataOnly: true, noHook: true, noCache: true, hidden: options.hidden, forceNoHidden: options.forceNoHidden }
+  if (query) {
+    old = await this.recordFindOne(name, { query }, o)
+  } else {
+    o.thrownNotFound = false
+    old = await this.recordGet(name, id, o)
+  }
+  if (old) {
+    body = merge(omit(old, ['id', 'createdAt', 'updatedAt', 'removedAt']), omit(input, omitOnUpdate))
+    return await this.recordUpdate(name, old.id, body, options)
+  }
+  if (!query) input.id = id
+  body = omit(input, omitOnCreate)
+  return await this.recordCreate(name, body, options)
 }
 
 export default upsert

package/plugin/method/sanitize/body.js

@@ -1,6 +1,6 @@
 async function sanitizeBody ({ body = {}, schema = {}, partial, strict, extFields = [] }) {
   const { isSet, dayjs, callHandler } = this.app.bajo
-  const { has, isString, isNumber, concat } = this.app.bajo.lib._
+  const { has, isString, isNumber, concat } = this.lib._
   const result = {}
   for (const p of concat(schema.properties, extFields)) {
     if (partial && !has(body, p.name)) continue

package/plugin/method/sanitize/date.js

@@ -1,5 +1,5 @@
 function sanitizeDate (value, { input, output, silent = true } = {}) {
-  const { dayjs } = this.app.bajo.lib
+  const { dayjs } = this.lib
   if (value === 0) return null
   if (!output) output = input
   const dt = dayjs(value, input)

package/plugin/method/validate.js

@@ -20,7 +20,7 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } =
   const {
     isPlainObject, get, each, isEmpty, isString, forOwn, keys,
     find, isArray, has, cloneDeep, concat, without
-  } = this.app.bajo.lib._
+  } = this.lib._
   const obj = {}
   const me = this
   const refs = []
@@ -127,7 +127,7 @@ function buildFromDbSchema (schema, { fields = [], rule = {}, extFields = [] } =
 
 async function validate (value, joiSchema, { ns, fields, extFields, params } = {}) {
   const { defaultsDeep, isSet } = this.app.bajo
-  const { isString, forOwn, find } = this.app.bajo.lib._
+  const { isString, forOwn, find } = this.lib._
 
   ns = ns ?? [this.name]
   params = defaultsDeep(params, this.config.validationParams)

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.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 { fs } = this.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/plugin/.alias

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

package/plugin/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/plugin/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/plugin/method/aggregate-types.js

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

package/plugin/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/plugin/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/plugin/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/plugin/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/plugin/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/plugin/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/plugin/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/plugin/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/plugin/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

package/plugin/start.js

@@ -1,20 +0,0 @@
-import memDbStart from '../lib/mem-db/start.js'
-import memDbInstantiate from '../lib/mem-db/instantiate.js'
-
-async function start (conns = 'all', noRebuild = true) {
-  const { importModule, breakNsPath } = this.app.bajo
-  const { find, filter, isString, map } = this.app.bajo.lib._
-  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)
-}
-
-export default start