dobo 2.0.1 → 2.2.1

package/extend/bajoCli/applet/model.js

@@ -0,0 +1,22 @@
+async function model (path, ...args) {
+  const { importPkg } = this.app.bajo
+  const { isEmpty, map, find } = this.app.lib._
+  const { getOutputFormat, writeOutput } = this.app.bajoCli
+  const select = await importPkg('bajoCli:@inquirer/select')
+  const format = getOutputFormat()
+  if (isEmpty(this.models)) return this.print.fail('notFound%s', this.t('field.model'), { exit: this.app.applet })
+  let name = args[0]
+  if (isEmpty(name)) {
+    const choices = map(this.models, s => ({ value: s.name }))
+    name = await select({
+      message: this.print.buildText('selectModel'),
+      choices
+    })
+  }
+  const result = find(this.models, { name })
+  if (!result) return this.print.fail('cantFind%s%s', this.t('model'), name, { exit: this.app.applet })
+  this.print.info('done')
+  await writeOutput(result, path, format)
+}
+
+export default model

package/extend/bajoCli/applet/rebuild-model.js

@@ -0,0 +1,91 @@
+async function modelRebuild (path, ...args) {
+  const { importPkg } = this.app.bajo
+  const { outmatch } = this.app.lib
+  const { isEmpty, map, trim, without } = this.app.lib._
+  const [input, confirm, boxen] = await importPkg('bajoCli:@inquirer/input',
+    'bajoCli:@inquirer/confirm', 'bajoCli:boxen')
+  const models = map(this.models, 'name')
+  let names = args.join(' ')
+  if (isEmpty(models)) return this.print.fail('notFound%s', 'model', { exit: this.app.applet })
+  if (isEmpty(names)) {
+    names = await input({
+      message: this.print.buildText('enterModelName'),
+      default: '*'
+    })
+  }
+  const isMatch = outmatch(map(names.split(' '), m => trim(m)))
+  names = models.filter(isMatch)
+  if (names.length === 0) return this.print.fail('No model matched', true, { exit: this.app.applet })
+  console.log(boxen(names.join(' '), { title: this.t('model%d', names.length), padding: 0.5, borderStyle: 'round' }))
+  const answer = await confirm({
+    message: this.print.buildText('modelsWillBeRebuiltContinue'),
+    default: false
+  })
+  if (!answer) return this.print.fail('aborted', { exit: this.app.applet })
+  /*
+  const conns = []
+  for (const s of names) {
+    const { connection } = this.getInfo(s)
+    if (!conns.includes(connection.name)) conns.push(connection.name)
+  }
+  */
+  await this.start('all')
+  const result = { succed: 0, failed: 0, skipped: 0 }
+  const skipped = []
+  for (const s of names) {
+    const model = this.getModel(s)
+    const spin = this.print.spinner().start('rebuilding%s', model.name)
+    if (model.driver.memory) {
+      spin.warn('memoryDbSkipped%s', model.name)
+      continue
+    }
+    const exists = await model.exists({ spinner: spin })
+    if (exists) {
+      if (this.app.bajo.config.force) {
+        try {
+          await model.drop({ spinner: spin })
+          spin.setText('modelDropped%s', model.name)
+        } catch (err) {
+          spin.fail('errorDroppingModel%s%s', model.name, err.message)
+          result.failed++
+          continue
+        }
+      } else {
+        spin.fail('modelExistsNeedForce%s', model.name)
+        result.failed++
+        continue
+      }
+    }
+    try {
+      await model.build({ spinner: spin })
+      spin.succeed('modelCreated%s', model.name)
+      result.succed++
+    } catch (err) {
+      if (this.app.bajo.config.log.applet) console.error(err)
+      spin.fail('errorCreatingModel%s%s', model.name, err.message)
+      result.failed++
+    }
+  }
+  this.print.info('succeedFailSkip%d%d%d', result.succed, result.failed, result.skipped)
+  if (result.failed > 0) this.print.fatal('cantContinueAddFixture')
+  for (const s of without(names, ...skipped)) {
+    const model = this.getModel(s)
+    const spin = this.print.spinner().start('addingFixture%s', model.name)
+    if (model.driver.memory) {
+      spin.warn('memoryDbSkipped%s', model.name)
+      continue
+    }
+    try {
+      const fixture = await model.loadFixtures({ spinner: spin })
+      spin.succeed('fixtureAdded%s%s%s', model.name, fixture.success, fixture.failed)
+      result.succed++
+    } catch (err) {
+      if (this.app.bajo.config.log.applet) console.error(err)
+      spin.fail('errorAddingFixture%s%s', model.name, err.message)
+      result.failed++
+    }
+  }
+  this.app.exit()
+}
+
+export default modelRebuild

package/extend/bajoCli/applet/remove-record.js

@@ -0,0 +1,27 @@
+import postProcess from './lib/post-process.js'
+
+async function removeRecord (path, ...args) {
+  const { importPkg } = this.app.bajo
+  const { isEmpty, map } = this.app.lib._
+  const { parseKvString } = this.app.lib.aneka
+  const [input, select] = await importPkg('bajoCli:@inquirer/input', 'bajoCli:@inquirer/select')
+  if (isEmpty(this.models)) return this.print.fail('notFound%s', this.t('field.model'), { exit: this.app.applet })
+  let [model, id, options] = args
+  options = isEmpty(options) ? {} : parseKvString(options)
+  if (isEmpty(model)) {
+    model = await select({
+      message: this.print.buildText('selectModel'),
+      choices: map(this.models, s => ({ value: s.name }))
+    })
+  }
+  if (isEmpty(id + '')) {
+    id = await input({
+      message: this.print.buildText('enterRecordId'),
+      validate: text => isEmpty(text) ? this.t('idIsRequired') : true
+    })
+  }
+  await postProcess.call(this, { noConfirmation: options.noConfirmation, handler: 'removeRecord', params: [model, id, options], path, processMsg: 'Removing record' })
+  this.app.exit()
+}
+
+export default removeRecord

package/extend/bajoCli/applet/update-record.js

@@ -0,0 +1,44 @@
+import postProcess from './lib/post-process.js'
+
+async function updateRecord (path, ...args) {
+  const { importPkg } = this.app.bajo
+  const { isEmpty, map } = this.app.lib._
+  const { parseKvString } = this.app.lib.aneka
+  const [input, select, boxen] = await importPkg('bajoCli:@inquirer/input',
+    'bajoCli:@inquirer/select', 'bajoCli:boxen')
+  if (isEmpty(this.models)) return this.print.fail('notFound%s', this.t('field.model'), { exit: this.app.applet })
+  let [model, id, body, options] = args
+  options = isEmpty(options) ? {} : parseKvString(options)
+  if (isEmpty(model)) {
+    model = await select({
+      message: this.print.buildText('selectModel'),
+      choices: map(this.models, s => ({ value: s.name }))
+    })
+  }
+  if (isEmpty(id + '')) {
+    id = await input({
+      message: this.print.buildText('enterRecordId'),
+      validate: text => isEmpty(text) ? this.t('idIsRequired') : true
+    })
+  }
+  if (isEmpty(body)) {
+    body = await input({
+      message: this.print.buildText('enterPayload'),
+      validate: text => {
+        if (isEmpty(text)) return this.t('payloadRequired')
+        return true
+      }
+    })
+  }
+  let payload
+  try {
+    payload = body[0] === '{' ? JSON.parse(body) : parseKvString(body)
+  } catch (err) {
+    return this.print.fail('invalidPayloadSyntax', { exit: this.app.applet })
+  }
+  console.log(boxen(JSON.stringify(payload, null, 2), { title: model, padding: 0.5, borderStyle: 'round' }))
+  await postProcess.call(this, { noConfirmation: options.noConfirmation, handler: 'updateRecord', params: [model, id, payload, options], path, processMsg: 'Updating record' })
+  this.app.exit()
+}
+
+export default updateRecord

package/extend/dobo/driver/memory.js

@@ -0,0 +1,170 @@
+import { Query } from 'mingo'
+
+async function memoryDriverFactory () {
+  const { DoboDriver } = this.app.baseClass
+  const { findIndex, pullAt, omit, has } = this.app.lib._
+  const { defaultsDeep } = this.app.lib.aneka
+
+  class DoboMemoryDriver extends DoboDriver {
+    constructor (plugin, name, options) {
+      super(plugin, name, options)
+      this.idGenerator = 'ulid'
+      this.saving = true
+      this.memory = true
+      this.autoSave = []
+      this.storage = {}
+      this.support = {
+        propType: {
+          object: true,
+          array: true
+        }
+      }
+    }
+
+    async _loadFromFile (model, dir) {
+      const { fs } = this.app.lib
+      this.autoSave.push(model.name)
+      const file = `${dir}/${model.name}.json`
+      if (!fs.existsSync(file)) return
+      try {
+        const data = fs.readFileSync(file, 'utf8')
+        this.storage[model.name] = JSON.parse(data)
+      } catch (err) {
+        this.fatal('cantLoad%s%s', model.name, err.message)
+      }
+    }
+
+    async sanitizeConnection (conn) {
+      await super.sanitizeConnection(conn)
+      conn.memory = true
+    }
+
+    async connect (connection, noRebuild) {
+      const conn = this.plugin.getConnection('memory')
+      const models = this.plugin.getModelsByConnection(conn.name)
+      const { getPluginDataDir } = this.app.bajo
+      const { fs } = this.app.lib
+      const pdir = `${getPluginDataDir(this.plugin.ns)}/memDb/data` // persistence dir
+      fs.ensureDirSync(pdir)
+      conn.autoSave = conn.autoSave ?? []
+      for (const model of models) {
+        this.storage[model.name] = this.storage[model.name] ?? [] // init empty model
+        if (conn.autoSave.includes(model.name)) await this._loadFromFile(model, pdir)
+        await model.loadFixtures()
+      }
+      if (conn.autoSave.length === 0) return
+      setInterval(() => {
+        if (!this.saving) return
+        this.saving = true
+        for (const item of conn.autoSave) {
+          const data = this.storage[item]
+          fs.writeFileSync(`${pdir}/${item}.json`, JSON.stringify(data), 'utf8')
+        }
+        this.saving = false
+      }, this.plugin.config.memDb.autoSaveDur)
+    }
+
+    async _getOldRecord (model, id, options = {}) {
+      const idx = findIndex(this.storage[model.name], { _id: id })
+      const oldData = this.storage[model.name][idx]
+      return { idx, oldData }
+    }
+
+    async modelExists (model, options = {}) {
+      return { data: has(this.storage, model.name) }
+    }
+
+    async buildModel (model, options = {}) {
+      if (has(this.storage, model.name)) throw this.plugin.error('exist%s%s', this.plugin.t('model'), model.name)
+      this.storage[model.name] = []
+      if (options.noResult) return
+      return { data: true }
+    }
+
+    async dropModel (model, options = {}) {
+      if (!has(this.storage, model.name)) throw this.plugin.error('notFound%s%s', this.plugin.t('model'), model.name)
+      delete this.storage[model.name]
+      if (options.noResult) return
+      return { data: true }
+    }
+
+    async createRecord (model, body = {}, options = {}) {
+      this.storage[model.name].push(body)
+      return { data: body }
+    }
+
+    async getRecord (model, id, options = {}) {
+      const { oldData: data } = await this._getOldRecord(model, id)
+      return { data }
+    }
+
+    async updateRecord (model, id, body = {}, options = {}) {
+      const { idx, oldData } = await this._getOldRecord(model, id)
+      const data = defaultsDeep(body, oldData)
+      this.storage[model.name][idx] = data
+      return { oldData, data }
+    }
+
+    async removeRecord (model, id, options = {}) {
+      const { idx, oldData } = await this._getOldRecord(model, id)
+      pullAt(this.storage[model.name], idx)
+      return { oldData }
+    }
+
+    async clearRecord (model, options = {}) {
+      this.storage[model.name] = []
+      if (options.noResult) return
+      return { data: true }
+    }
+
+    async findRecord (model, filter = {}, options = {}) {
+      const { limit, skip, sort, page } = filter
+      const { data: count = 0 } = await this.countRecord(model, filter, options)
+      const cursor = this._getCursor(model, filter)
+      if (sort) cursor.sort(sort)
+      if (!options.noLimit) cursor.skip(skip).limit(limit)
+      let result = { data: cursor.all(), page, limit, count, pages: Math.ceil(count / limit) }
+      if (!options.count) result = omit(result, ['count', 'pages'])
+      return result
+    }
+
+    async findAllRecord (model, filter = {}, options = {}) {
+      const { sort } = filter
+      const { data: count = 0 } = await this.countRecord(model, filter, options)
+      const cursor = this._getCursor(model, filter)
+      if (sort) cursor.sort(sort)
+      let result = { data: cursor.all(), count }
+      if (!options.count) result = omit(result, ['count'])
+      return result
+    }
+
+    async countRecord (model, filter = {}, options = {}) {
+      const cursor = this._getCursor(model, filter)
+      const data = cursor.all().length
+      return { data }
+    }
+
+    async createAggregate (model, filter = {}, params = {}, options = {}) {
+      const item = await this.findAllRecord(model, filter, options)
+      const result = this.app.dobo.calcAggregate({ data: item.data, ...params })
+      return { data: result }
+    }
+
+    async createHistogram (model, filter = {}, params = {}, options = {}) {
+      const item = await this.findAllRecord(model, filter, options)
+      const result = this.app.dobo.calcHistogram({ data: item.data, ...params })
+      return { data: result }
+    }
+
+    _getCursor (model, filter) {
+      const criteria = filter.query ?? {}
+      const q = new Query(criteria, { idKey: '_id' })
+      return q.find(this.storage[model.name])
+    }
+  }
+
+  this.app.baseClass.DoboMemoryDriver = DoboMemoryDriver
+  return DoboMemoryDriver
+}
+
+export default memoryDriverFactory

package/extend/dobo/feature/created-at.js

@@ -1,18 +1,20 @@
 async function createdAt (opts = {}) {
   opts.fieldName = opts.fieldName ?? 'createdAt'
+  opts.noOverwrite = opts.noOverwrite ?? false
   return {
-    properties: {
+    properties: [{
       name: opts.fieldName,
       type: 'datetime',
       index: true
-    },
-    hook: {
-      beforeCreate: async function ({ body }) {
+    }],
+    hooks: [{
+      name: 'beforeCreateRecord',
+      handler: async function (body, options) {
         const { isSet } = this.app.lib.aneka
-        const now = new Date()
-        if (opts.overwrite || !isSet(body[opts.fieldName])) body[opts.fieldName] = now
+        if (opts.noOverwrite) body[opts.fieldName] = new Date()
+        else if (!isSet(body[opts.fieldName])) body[opts.fieldName] = new Date()
       }
-    }
+    }]
   }
 }
 

package/extend/dobo/feature/immutable.js

@@ -0,0 +1,30 @@
+async function beforeRemoveRecord (id, opts) {
+  const { get } = this.app.lib._
+  const record = await this.driver.getRecord(this, id)
+  const immutable = get(record.data, opts.fieldName)
+  if (immutable) throw this.plugin.error('recordImmutable%s%s', id, this.name, { statusCode: 423 })
+}
+
+async function immutable (opts = {}) {
+  opts.fieldName = opts.fieldName ?? '_immutable'
+  return {
+    properties: {
+      name: opts.fieldName,
+      type: 'boolean',
+      hidden: true
+    },
+    hooks: [{
+      name: 'beforeUpdateRecord',
+      handler: async function (id, body, options) {
+        await beforeRemoveRecord.call(this, id, opts)
+      }
+    }, {
+      name: 'beforeRemoveRecord',
+      handler: async function (id, options) {
+        await beforeRemoveRecord.call(this, id, opts)
+      }
+    }]
+  }
+}
+
+export default immutable

package/extend/dobo/feature/removed-at.js

@@ -1,4 +1,4 @@
-async function beforeFind ({ filter = {}, options }, opts) {
+async function beforeFindRecord ({ filter = {} }, opts) {
   filter.query = filter.query ?? {}
   const { isEmpty, set } = this.app.lib._
   const q = { $and: [] }
@@ -10,75 +10,53 @@ async function beforeFind ({ filter = {}, options }, opts) {
   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) {
+async function afterGetRecord ({ id, record = {} }, opts) {
   const { isEmpty } = this.app.lib._
-  if (!isEmpty(record.data[opts.fieldName])) throw this.error('recordNotFound%s%s', id, schema.name, { statusCode: 404 })
-  delete record.data[opts.fieldName]
+  if (!isEmpty(record.data[opts.fieldName])) throw this.error('recordNotFound%s%s', id, this.name, { statusCode: 404 })
 }
 
-async function beforeCreate ({ body }, opts) {
+async function beforeCreateRecord ({ 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'
+  opts.fieldName = opts.fieldName ?? '_removedAt'
   return {
     properties: {
       name: opts.fieldName,
       type: 'datetime',
-      index: true
+      index: true,
+      hidden: 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)
+    hooks: [{
+      name: 'beforeFindRecord',
+      handler: async function (filter, options) {
+        await beforeFindRecord.call(this, { filter, options }, opts)
+      }
+    }, {
+      name: 'afterGetRecord',
+      handler: async function (id, record, options) {
+        await afterGetRecord.call(this, { record }, opts)
+      }
+    }, {
+      name: 'beforeCreateRecord',
+      handler: async function (body, options) {
+        await beforeCreateRecord.call(this, { body }, opts)
+      }
+    }, {
+      name: 'beforeUpdateRecord',
+      handler: async function (id, body, options) {
+        await beforeCreateRecord.call(this, { body }, opts)
+      }
+    }, {
+      name: 'beforeRemoveRecord',
+      handler: async function (id, options) {
         const { set } = this.app.lib._
         const body = set({}, opts.fieldName, new Date())
-        const record = await recordUpdate(schema.name, id, body, { dataOnly: false, noValidation: true, noFeatureHook: true })
+        const record = await this.driver.recordUpdate(this, id, body, { noResult: false })
         options.record = { oldData: record.oldData }
-      },
-      afterRemove: async function ({ record }) {
-        delete record.oldData[opts.fieldName]
       }
-    }
+    }]
   }
 }
 

package/extend/dobo/feature/updated-at.js

@@ -1,24 +1,26 @@
 async function updatedAt (opts = {}) {
+  const { isSet } = this.app.lib.aneka
   opts.fieldName = opts.fieldName ?? 'updatedAt'
-  opts.overwrite = opts.overwrite ?? true
+  opts.noOverwrite = opts.noOverwrite ?? false
   return {
     properties: {
       name: opts.fieldName,
       type: 'datetime',
       index: true
     },
-    hook: {
-      beforeCreate: async function ({ body }) {
-        const { isSet } = this.app.lib.aneka
-        const now = new Date()
-        if (opts.overwrite || !isSet(body[opts.fieldName])) body[opts.fieldName] = now
-      },
-      beforeUpdate: async function ({ body }) {
-        const { isSet } = this.app.lib.aneka
-        const now = new Date()
-        if (opts.overwrite || !isSet(body[opts.fieldName])) body[opts.fieldName] = now
+    hooks: [{
+      name: 'beforeCreateRecord',
+      handler: async function (body, options) {
+        if (opts.noOverwrite) body[opts.fieldName] = new Date()
+        else if (!isSet(body[opts.fieldName])) body[opts.fieldName] = new Date()
       }
-    }
+    }, {
+      name: 'beforeUpdateRecord',
+      handler: async function (id, body, options) {
+        if (opts.noOverwrite) body[opts.fieldName] = new Date()
+        else if (!isSet(body[opts.fieldName])) body[opts.fieldName] = new Date()
+      }
+    }]
   }
 }
 

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

@@ -5,12 +5,8 @@ async function attachment (req, reply) {
   const { pascalCase } = this.app.lib.aneka
   const { routePath } = this.app.waibu
   const { fs } = this.app.lib
-  const items = await this.listAttachments({
-    model: req.params.model,
-    id: req.params.id,
-    field: req.params.field,
-    file: '*'
-  })
+  const mdl = this.app.dobo.getModel(req.params.model)
+  const items = await mdl.listAttachments(req.params.id, req.params.field, '*')
   let item = req.params.file === '_first' ? items[0] : undefined
   if (!item) {
     item = find(items, i => {