dobo 2.0.0 → 2.2.0

package/extend/bajoCli/applet/stat-count.js

@@ -1,24 +0,0 @@
-import postProcess from './lib/post-process.js'
-
-async function statCount (path, ...args) {
-  const { importPkg } = this.app.bajo
-  const { isEmpty, map } = this.lib._
-  const [select, input] = await importPkg('bajoCli:@inquirer/select', 'bajoCli:@inquirer/input')
-  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
-  let [schema, query] = args
-  if (isEmpty(schema)) {
-    schema = await select({
-      message: this.print.write('selectSchema'),
-      choices: map(this.schemas, s => ({ value: s.name }))
-    })
-  }
-  if (isEmpty(query)) {
-    query = await input({
-      message: this.print.write('enterQueryIfAny')
-    })
-  }
-  const filter = { query }
-  await postProcess.call(this, { noConfirmation: true, handler: 'statCount', params: [schema, filter], path, processMsg: 'Counting record(s)' })
-}
-
-export default statCount

package/lib/build-bulk-action.js

@@ -1,12 +0,0 @@
-async function buildBulkAction (name, action, options = {}) {
-  const { fs, importModule } = this.app.bajo
-  const { camelCase } = this.lib._
-  const { schema, driver, connection } = await this.getInfo(name)
-  if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('methodIsDisabled%s%s', camelCase('bulk ' + action), name)
-  const file = `${driver.plugin}:/extend/${this.name}/method/bulk/${action}.js`
-  if (!fs.existsSync(file)) throw this.error('methodUnsupported%s%s', camelCase('bulk ' + action), name)
-  const handler = await importModule(file)
-  return { handler, schema, driver, connection }
-}
-
-export default buildBulkAction

package/lib/check-unique.js

@@ -1,39 +0,0 @@
-async function checkUnique ({ schema, body, id }) {
-  const { isSet } = this.lib.aneka
-  const { filter, map, set } = this.lib._
-  const singles = map(filter(schema.properties, p => (p.index ?? {}).type === 'unique'), 'name')
-  const opts = { noHook: true, noCache: true, thrownNotFound: false, forceNoHidden: true }
-  let old = {}
-  if (id) old = (await this.recordGet(schema.name, id, opts)) ?? {}
-  for (const s of singles) {
-    if (!isSet(body[s])) continue
-    if (id && body[s] === old[s]) continue
-    const query = set({}, s, body[s])
-    const resp = await this.recordFind(schema.name, { query, limit: 1 }, opts)
-    if (resp.length !== 0) {
-      const details = [{ field: s, error: 'uniqueConstraintError', value: id }]
-      throw this.error('uniqueConstraintError', { details, body })
-    }
-  }
-  const multis = filter(schema.indexes, i => i.type === 'unique')
-  for (const m of multis) {
-    const query = {}
-    let empty = true
-    let same = true
-    for (const f of m.fields) {
-      if (body[f]) empty = false
-      if (body[f] !== old[f]) same = false
-      query[f] = body[f]
-    }
-    if (empty || same) continue
-    const resp = await this.recordFind(schema.name, { query, limit: 1 }, { noHook: true, noCache: true, forceNoHidden: true })
-    if (resp.length !== 0) {
-      const details = map(m.fields, f => {
-        return { field: f, error: 'Unique constraint error' }
-      })
-      throw this.error('Unique constraint error', { details, body })
-    }
-  }
-}
-
-export default checkUnique

package/lib/collect-feature.js

@@ -1,25 +0,0 @@
-import path from 'path'
-
-async function handler ({ file }) {
-  const { name: ns } = this
-  const { importModule } = this.app.bajo
-  const { camelCase, isFunction } = this.lib._
-  const me = this.app.dobo
-
-  let name = camelCase(path.basename(file, '.js'))
-  if (ns !== me.name) name = `${ns}.${name}`
-  const mod = await importModule(file)
-  if (!isFunction(mod)) this.fatal('featureNotAsync%s', name)
-  me.feature[name] = mod
-  me.log.trace('- %s', name)
-}
-
-async function collectFeature () {
-  const { eachPlugins } = this.app.bajo
-  this.feature = {}
-  this.log.trace('loadingDbFeature')
-  await eachPlugins(handler, { glob: 'feature/*.js', prefix: this.name })
-  this.log.debug('totalLoadedFeatures%d', Object.keys(this.feature).length)
-}
-
-export default collectFeature

package/lib/collect-schemas.js

@@ -1,83 +0,0 @@
-import path from 'path'
-import sanitizeSchema from './sanitize-schema.js'
-
-async function handler ({ file }) {
-  const { name: ns, alias } = this
-  const { readConfig, eachPlugins } = this.app.bajo
-  const { pascalCase } = this.lib.aneka
-  const { get, isPlainObject, each, find, has, isArray, forOwn, isString, merge } = this.lib._
-  const { fastGlob } = this.lib
-
-  const base = path.basename(file, path.extname(file))
-  const defName = pascalCase(`${alias} ${base}`)
-  const mod = await readConfig(file, { ns, ignoreError: true })
-  if (!isPlainObject(mod)) this.fatal('invalidSchema%s', defName)
-  const forcedConn = get(this, `app.${ns}.config.dobo.schemaConnection.${base}`)
-  if (forcedConn) mod.connection = forcedConn
-  if (!mod.connection) mod.connection = 'default'
-  mod.name = mod.name ?? defName
-  mod.file = file
-  mod.ns = ns
-  mod.attachment = mod.attachment ?? true
-  mod.feature = mod.feature ?? []
-  mod.buildLevel = mod.buildLevel ?? 999
-  const feats = []
-  if (isArray(mod.feature)) {
-    each(mod.feature, f => {
-      if (isString(f)) feats.push({ name: f })
-      else if (isPlainObject(f)) feats.push(f)
-    })
-  } else if (isPlainObject(mod.feature)) {
-    forOwn(mod.feature, (v, k) => {
-      feats.push(merge({}, v, { name: k }))
-    })
-  }
-  mod.feature = feats
-  mod.properties = mod.properties ?? []
-  // if ((mod.properties ?? []).length === 0) this.fatal('noPropsFoundOnSchema%s', mod.name)
-  // schema extender
-  await eachPlugins(async function ({ dir }) {
-    const { name: ns } = this
-    const glob = `${dir}/extend/dobo/extend/${mod.ns}/schema/${base}.*`
-    const files = await fastGlob(glob)
-    for (const file of files) {
-      const extender = await readConfig(file, { ns, ignoreError: true })
-      if (!isPlainObject(extender)) return undefined
-      each(extender.properties ?? [], p => {
-        if (isString(p) && mod.properties.includes(p)) return undefined
-        else if (find(mod.properties, { name: p.name })) return undefined
-        mod.properties.push(p)
-      })
-      const feats = []
-      if (isArray(extender.feature)) {
-        each(extender.feature, f => {
-          if (isString(f)) feats.push({ name: f })
-          else if (isPlainObject(f)) feats.push(f)
-        })
-      } else if (isPlainObject(extender.feature)) {
-        forOwn(extender.feature, (v, k) => {
-          feats.push(merge({}, v, { name: k }))
-        })
-      }
-      if (feats.length > 0) mod.feature.push(...feats)
-      if (ns === this.app.bajo.mainNs) {
-        each(['connection', 'name'], i => {
-          if (has(extender, i)) mod[i] = extender[i]
-        })
-      }
-      mod.extender = mod.extender ?? []
-      mod.extender.push(ns)
-    }
-  })
-  return mod
-}
-
-async function collectSchemas () {
-  const { eachPlugins } = this.app.bajo
-  const { isEmpty } = this.lib._
-  const result = await eachPlugins(handler, { glob: 'schema/*.*', prefix: this.name })
-  if (isEmpty(result)) this.log.warn('notFound%s', this.print.write('schema'))
-  else await sanitizeSchema.call(this, result)
-}
-
-export default collectSchemas

package/lib/exec-feature-hook.js

@@ -1,13 +0,0 @@
-async function execFeatureHook (name, params = {}) {
-  const { get } = this.lib._
-  const { schema } = params
-  for (const f of schema.feature) {
-    const fn = get(this.feature, f.name)
-    if (!fn) continue
-    const input = await fn.call(this, f)
-    const hook = get(input, 'hook.' + name)
-    if (hook) await hook.call(this, params)
-  }
-}
-
-export default execFeatureHook

package/lib/exec-validation.js

@@ -1,21 +0,0 @@
-async function execValidation ({ name, body, options, partial }) {
-  const { runHook } = this.app.bajo
-  const { keys, camelCase } = this.lib._
-  const { noHook } = options
-  if (!noHook) {
-    await runHook(`${this.name}:beforeRecordValidation`, name, body, options)
-    await runHook(`${this.name}.${camelCase(name)}:beforeRecordValidation`, body, options)
-  }
-  const { validation = {} } = options
-  if (partial) {
-    validation.fields = keys(body)
-  }
-  body = await this.validate(body, name, validation)
-  if (!noHook) {
-    await runHook(`${this.name}:afterRecordValidation`, name, body, options)
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordValidation`, body, options)
-  }
-  return body
-}
-
-export default execValidation

package/lib/generic-prop-sanitizer.js

@@ -1,31 +0,0 @@
-const indexTypes = ['default', 'unique', 'primary', 'fulltext']
-
-async function genericPropSanitizer ({ prop, schema, driver }) {
-  const { join } = this.app.bajo
-  const { has, get, each } = this.lib._
-  const def = this.propType[prop.type]
-  // detect from drivers
-  if (prop.type === 'string') {
-    def.minLength = prop.minLength ?? 0
-    def.maxLength = prop.maxLength ?? 255
-    if (has(prop, 'length')) def.maxLength = prop.length
-    if (prop.required && def.minLength === 0) def.minLength = 1
-    if (def.minLength > 0) prop.required = true
-  }
-  if (prop.autoInc && !['smallint', 'integer'].includes(prop.type)) delete prop.autoInc
-  each(['minLength', 'maxLength', 'kind'], p => {
-    if (!has(def, p)) {
-      delete prop[p]
-      return undefined
-    }
-    prop[p] = get(prop, p, get(this.config, `default.property.${prop.type}.${p}`, def[p]))
-    if (def.choices && !def.choices.includes(prop[p])) {
-      this.fatal('unsupportedAllowedChoices%s%s%s%s%s', p, prop[p], prop.name, schema.name, join(def.choices))
-    }
-  })
-  if (prop.index && !indexTypes.includes(prop.index.type)) {
-    this.fatal('unsupportedIndexType%s%s%s%s', prop.index.type, prop.name, schema.name, join(indexTypes))
-  }
-}
-
-export default genericPropSanitizer

package/lib/handle-attachment-upload.js

@@ -1,16 +0,0 @@
-async function handleAttachmentUpload ({ action, name, id, options = {} } = {}) {
-  const { getPluginDataDir } = this.app.bajo
-  const { fs } = this.lib
-  const { req, mimeType, stats, setFile, setField } = options
-
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  if (action === 'remove') {
-    const dir = `${getPluginDataDir(this.name)}/attachment/${name}/${id}`
-    await fs.remove(dir)
-    return
-  }
-  return this.attachmentCopyUploaded(name, id, { req, mimeType, stats, setFile, setField })
-}
-
-export default handleAttachmentUpload

package/lib/mem-db/conn-sanitizer.js

@@ -1,8 +0,0 @@
-async function connSanitizer (connection) {
-  const { pick } = this.lib._
-  const result = pick(connection, ['type', 'name', 'driver'])
-  result.memory = true
-  return result
-}
-
-export default connSanitizer

package/lib/mem-db/instantiate.js

@@ -1,41 +0,0 @@
-let saving = false
-
-async function instantiate ({ connection, schemas, noRebuild }) {
-  const { getPluginDataDir } = this.app.bajo
-  const { fs } = this.lib
-  const { pick } = this.lib._
-  this.memDb = this.memDb ?? {}
-  this.memDb.storage = this.memDb.storage ?? {}
-  this.memDb.instances = this.memDb.instances ?? []
-  const instance = pick(connection, ['name', 'type'])
-  this.memDb.instances.push(instance)
-  // if (noRebuild) return
-  const pdir = `${getPluginDataDir(this.name)}/memDb/data` // persistence dir
-  fs.ensureDirSync(pdir)
-  const persistence = []
-  for (const schema of schemas) {
-    this.memDb.storage[schema.name] = this.memDb.storage[schema.name] ?? [] // init empty model
-    if (!schema.persistence) continue
-    persistence.push(schema.name)
-    // load if persistence
-    const file = `${pdir}/${schema.name}.json`
-    if (!fs.existsSync(file)) continue
-    try {
-      const data = fs.readFileSync(file, 'utf8')
-      this.memDb.storage[schema.name] = JSON.parse(data)
-    } catch (err) {
-      this.fatal('cantLoad%s%s', schema.name, err.message)
-    }
-  }
-  setInterval(() => {
-    if (saving) return
-    saving = true
-    for (const item of persistence) {
-      const data = this.memDb.storage[item]
-      fs.writeFileSync(`${pdir}/${item}.json`, JSON.stringify(data), 'utf8')
-    }
-    saving = false
-  }, this.config.memDb.persistence.syncPeriod * 1000)
-}
-
-export default instantiate

package/lib/mem-db/method/model/clear.js

@@ -1,6 +0,0 @@
-async function clear ({ schema, options = {} }) {
-  this.memDb.storage[schema.name].splice(0)
-  return true
-}
-
-export default clear

package/lib/mem-db/method/model/create.js

@@ -1,5 +0,0 @@
-async function exists ({ schema, options = {} }) {
-  this.memDb.storage[schema.name] = []
-}
-
-export default exists

package/lib/mem-db/method/model/drop.js

@@ -1,5 +0,0 @@
-async function exists ({ schema, options = {} }) {
-  this.memDb.storage[schema.name].splice(0)
-}
-
-export default exists

package/lib/mem-db/method/model/exists.js

@@ -1,5 +0,0 @@
-async function exists ({ schema, options = {} }) {
-  return true
-}
-
-export default exists

package/lib/mem-db/method/record/create.js

@@ -1,12 +0,0 @@
-import getRecord from './get.js'
-
-async function create ({ schema, body, options = {} }) {
-  const { noResult } = options
-  const exist = await getRecord.call(this, { schema, id: body.id, options: { thrownNotFound: false } })
-  if (exist.data) throw this.error('recordExists%s%s', body.id, schema.name)
-  this.memDb.storage[schema.name].push(body)
-  if (noResult) return
-  return { data: body }
-}
-
-export default create

package/lib/mem-db/method/record/find.js

@@ -1,20 +0,0 @@
-import { Query } from 'mingo'
-
-async function find ({ schema, filter = {}, options = {} }) {
-  const { prepPagination } = this.app.dobo
-  const { omit } = this.lib._
-  const { limit, skip, sort, page } = await prepPagination(filter, schema)
-  const criteria = filter.query ?? {}
-  const q = new Query(criteria, { idKey: 'id' })
-  let cursor = q.find(this.memDb.storage[schema.name])
-  let count = 0
-  if (options.count && !options.dataOnly) count = cursor.count()
-  cursor = q.find(this.memDb.storage[schema.name])
-  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
-}
-
-export default find

package/lib/mem-db/method/record/get.js

@@ -1,9 +0,0 @@
-async function get ({ schema, id, options = {} }) {
-  const { thrownNotFound = true } = options
-  const { find } = this.lib._
-  const result = find(this.memDb.storage[schema.name], { id })
-  if (!result && thrownNotFound) throw this.error('recordNotFound%s%s', id, schema.name, { statusCode: 404 })
-  return { data: result }
-}
-
-export default get

package/lib/mem-db/method/record/remove.js

@@ -1,13 +0,0 @@
-import getRecord from './get.js'
-
-async function remove ({ schema, id, options = {} }) {
-  const { noResult } = options
-  const { findIndex, pullAt } = this.lib._
-  const rec = noResult ? undefined : await getRecord.call(this, { schema, id })
-  const idx = findIndex(this.memDb.storage[schema.name], { id })
-  pullAt(this.memDb.storage[schema.name], [idx])
-  if (noResult) return
-  return { oldData: rec.data }
-}
-
-export default remove

package/lib/mem-db/method/record/update.js

@@ -1,15 +0,0 @@
-import getRecord from './get.js'
-
-async function update ({ schema, id, body, options }) {
-  const { noResult } = options
-  const { findIndex, merge } = this.lib._
-  const old = noResult ? undefined : await getRecord.call(this, { schema, id })
-  const idx = findIndex(this.memDb.storage[schema.name], { id })
-  const current = this.memDb.storage[schema.name][idx]
-  this.memDb.storage[schema.name][idx] = merge(current, body)
-  if (noResult) return
-  const result = this.memDb.storage[schema.name][idx]
-  return { oldData: old.data, data: result }
-}
-
-export default update

package/lib/mem-db/method/stat/count.js

@@ -1,11 +0,0 @@
-import { Query } from 'mingo'
-
-async function count ({ schema, filter = {}, options = {} }) {
-  const criteria = filter.query ?? {}
-  const q = new Query(criteria, { idKey: 'id' })
-  const cursor = q.find(this.memDb.storage[schema.name])
-  const count = cursor.count()
-  return { data: count }
-}
-
-export default count

package/lib/mem-db/start.js

@@ -1,25 +0,0 @@
-import addFixtures from '../add-fixtures.js'
-
-async function start () {
-  const { filter, map } = this.lib._
-
-  const conns = filter(this.connections, { type: 'dobo:memory' })
-  const schemas = filter(this.schemas, s => {
-    const names = map(conns, 'name')
-    return names.includes(s.connection)
-  })
-  if (schemas.length === 0) return
-  this.log.debug('addingFixtureToMemDb')
-  for (const schema of schemas) {
-    if (schema.persistence) {
-      this.log.warn('addingMemoryPersistenceIgnored', schema.name)
-      continue
-    }
-    let { success, error } = await addFixtures.call(this, schema.name)
-    success = success ?? 0
-    error = error ?? 0
-    this.log.trace('- %s@%s (%d/%d)', schema.name, schema.connection, success, success + error)
-  }
-}
-
-export default start

package/lib/merge-attachment-info.js

@@ -1,16 +0,0 @@
-async function mergeAttachmentInfo (rec, source, { mimeType, stats, fullPath }) {
-  const { importPkg } = this.app.bajo
-  const { fs } = this.lib
-  const { pick } = this.lib._
-  if (!this.app.waibu) return
-  const mime = await importPkg('waibu:mime')
-
-  if (mimeType) rec.mimeType = mime.getType(rec.file)
-  if (fullPath) rec.fullPath = source
-  if (stats) {
-    const s = fs.statSync(source)
-    rec.stats = pick(s, ['size', 'atime', 'ctime', 'mtime'])
-  }
-}
-
-export default mergeAttachmentInfo

package/lib/multi-rel-rows.js

@@ -1,42 +0,0 @@
-async function multiRelRows ({ schema, records, options = {} }) {
-  const { isSet } = this.lib.aneka
-  const { uniq, find, map } = this.lib._
-  const props = schema.properties.filter(p => isSet(p.rel) && !(options.hidden ?? []).includes(p.name))
-  // const props = schema.properties.filter(p => isSet(p.rel))
-  options.rels = options.rels ?? []
-  if (props.length > 0) {
-    for (const prop of props) {
-      for (const key in prop.rel) {
-        if (!((typeof options.rels === 'string' && ['*', 'all'].includes(options.rels)) || options.rels.includes(key))) continue
-        const val = prop.rel[key]
-        if (val.fields.length === 0) continue
-        if (val.type !== 'one-to-one') continue
-        const relschema = this.getSchema(val.schema)
-        const matches = uniq(map(records, r => {
-          let v = r[prop.name]
-          if (val.propName === 'id') {
-            const idField = find(relschema.properties, { name: 'id' })
-            if (idField.type === 'integer') v = parseInt(v)
-          }
-          return v
-        }))
-        const query = {}
-        query[val.propName] = { $in: matches }
-        const relFilter = { query, limit: matches.length }
-        const relOptions = { dataOnly: true, rels: [] }
-        const results = await this.recordFind(relschema.name, relFilter, relOptions)
-        const fields = [...val.fields]
-        if (!fields.includes(prop.name)) fields.push(prop.name)
-        for (const i in records) {
-          records[i]._rel = records[i]._rel ?? {}
-          const rec = records[i]
-          const res = results.find(r => (r[val.propName] + '') === rec[prop.name] + '')
-          if (res) records[i]._rel[key] = await this.pickRecord({ record: res, fields, schema: relschema })
-          else records[i]._rel[key] = {}
-        }
-      }
-    }
-  }
-}
-
-export default multiRelRows

package/lib/resolve-method.js

@@ -1,16 +0,0 @@
-async function resolveMethod (name, method, options = {}) {
-  const { importModule } = this.app.bajo
-  const { fs } = this.lib
-  const { camelCase } = this.lib._
-  const { schema, driver, connection } = this.getInfo(name)
-  const [group, action] = method.split('-')
-  if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('methodIsDisabled%s%s', camelCase(method), name)
-  let file
-  if (connection.name === 'memory') file = `${this.app[driver.ns].dir.pkg}/lib/mem-db/method/${group}/${action}.js`
-  else file = `${this.app[driver.ns].dir.pkg}/extend/${this.name}/method/${group}/${action}.js`
-  if (!fs.existsSync(file)) throw this.error('methodUnsupported%s%s', camelCase(method), name)
-  const handler = await importModule(file)
-  return { handler, schema, driver, connection }
-}
-
-export default resolveMethod