dobo 1.0.0 → 1.0.1

package/lib/add-fixtures.js

@@ -0,0 +1,53 @@
+import path from 'path'
+
+async function addFixture (name, spin) {
+  const { resolvePath, readConfig, eachPlugins, getPluginDataDir } = this.app.bajo
+  const { isEmpty, isArray } = this.app.bajo.lib._
+  const { schema, connection } = this.getInfo(name)
+  if (connection.proxy) {
+    this.log.warn('\'%s\' is bound to a proxied connection, skipped!', schema.name)
+    return
+  }
+  const result = { success: 0, failed: 0 }
+  const base = path.basename(schema.file, path.extname(schema.file))
+  // original
+  const pattern = resolvePath(`${path.dirname(schema.file)}/../fixture/${base}.*`)
+  let items = await readConfig(pattern, { ns: schema.ns, ignoreError: true })
+  if (isEmpty(items)) items = []
+  // override
+  const overrides = await readConfig(`${getPluginDataDir(this.name)}/fixture/override/${schema.name}.*`, { ns: this.name, ignoreError: true })
+  if (isArray(overrides) && !isEmpty(overrides)) items = overrides
+  // extend
+  const me = this
+  await eachPlugins(async function ({ dir, ns }) {
+    const extend = await readConfig(`${dir}/${me.name}/fixture/extend/${schema.name}.*`, { ns, ignoreError: true })
+    if (isArray(extend) && !isEmpty(extend)) items.push(...extend)
+  })
+  if (isEmpty(items)) return result
+  const opts = { noHook: true, noCache: true }
+  for (const item of items) {
+    try {
+      for (const k in item) {
+        const v = item[k]
+        if (typeof v === 'string' && v.slice(0, 2) === '?:') {
+          let [, model, field, ...query] = v.split(':')
+          if (!field) field = 'id'
+          const recs = await this.recordFind(model, { query: query.join(':') }, opts)
+          item[k] = (recs[0] ?? {})[field]
+        }
+        if (v === null) item[k] = undefined
+      }
+      await this.recordCreate(schema.name, item, { force: true })
+      result.success++
+      if (spin) spin.setText('%s: %d of %d records added', schema.name, result.success, items.length)
+    } catch (err) {
+      err.model = schema.name
+      if (this.app.bajo.applet) this.print.fail(this.validationErrorMessage(err))
+      // else this.log.error('Add fixture \'%s@%s\' error: %s', schema.name, schema.connection, err.message)
+      result.failed++
+    }
+  }
+  return result
+}
+
+export default addFixture

package/lib/build-bulk-action.js

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

package/lib/check-unique.js

@@ -0,0 +1,39 @@
+async function checkUnique ({ schema, body, id }) {
+  const { isSet } = this.app.bajo
+  const { filter, map, set } = this.app.bajo.lib._
+  const singles = map(filter(schema.properties, p => (p.index ?? {}).type === 'unique'), 'name')
+  const opts = { noHook: true, noCache: true, thrownNotFound: false }
+  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: 'Unique constraint error', value: id }]
+      throw this.error('Unique constraint error', { details })
+    }
+  }
+  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 })
+    if (resp.length !== 0) {
+      const details = map(m.fields, f => {
+        return { field: f, error: 'Unique constraint error' }
+      })
+      throw this.error('Unique constraint error', { details })
+    }
+  }
+}
+
+export default checkUnique

package/lib/collect-connections.js

@@ -0,0 +1,25 @@
+async function defSanitizer (item) {
+  // if (!item.connection) fatal('\'%s@%s\' key is required', 'connection', item.name, { payload: item })
+  const { merge } = this.app.bajo.lib._
+  return merge({}, item)
+}
+
+async function collectConnections ({ item, index, options }) {
+  const conn = item
+  const { importModule, breakNsPath } = this.app.bajo
+  const { has, find } = this.app.bajo.lib._
+  if (!has(conn, 'type')) this.fatal('Connection must have a valid DB type')
+  const [ns, type] = breakNsPath(conn.type)
+  const driver = find(this.drivers, { ns, type })
+  if (!driver) this.fatal('Unsupported DB type \'%s\'', conn.type)
+  let file = `${ns}:/${this.name}/lib/${type}/conn-sanitizer.js`
+  if (driver.provider) file = `${driver.provider}:/${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
+}
+
+export default collectConnections

package/lib/collect-drivers.js

@@ -0,0 +1,32 @@
+async function collectDrivers () {
+  const { eachPlugins, readConfig, runHook } = this.app.bajo
+  const { isString, find, pick, merge } = this.app.bajo.lib._
+  const me = this
+  me.drivers = []
+  await runHook(`${this.name}:beforeCollectDrivers`)
+  await eachPlugins(async function ({ file, ns }) {
+    const info = await readConfig(file, { ns })
+    if (!info.type) this.fatal('A DB driver must provide at least one database type')
+    if (!info.driver) this.fatal('A DB driver must have a driver name')
+    if (isString(info.type)) info.type = [info.type]
+    if (!info.idField) info.idField = me.config.defaults.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('Database type \'%s\' already supported by driver \'%s\'', type, info.driver)
+      const driver = pick(find(me.app[ns].drivers, { name: type }) ?? {}, ['dialect', 'idField', 'lowerCaseColl', 'returning'])
+      const ext = {
+        type,
+        ns,
+        provider,
+        driver: info.driver,
+        idField: info.idField
+      }
+      me.drivers.push(merge(ext, driver))
+    }
+  }, { glob: 'boot/driver.*', baseNs: this.name })
+  await runHook(`${this.name}:afterCollectDrivers`)
+}
+
+export default collectDrivers

package/lib/collect-feature.js

@@ -0,0 +1,23 @@
+import path from 'path'
+
+async function handler ({ file, alias, ns }) {
+  const { importModule } = this.app.bajo
+  const { camelCase, isFunction } = this.app.bajo.lib._
+  let name = camelCase(path.basename(file, '.js'))
+  if (ns !== this.name) name = `${ns}:${name}`
+  const mod = await importModule(file)
+  if (!isFunction(mod)) this.fatal('Feature \'%s\' should be an async function', name)
+  this.feature = this.feature ?? {}
+  this.feature[name] = mod
+  this.log.trace('- %s', name)
+}
+
+async function collectFeature () {
+  const { eachPlugins } = this.app.bajo
+  this.feature = {}
+  this.log.trace('Loading DB feature')
+  await eachPlugins(handler, { glob: 'feature/*.js', baseNs: this.ns })
+  this.log.debug('Total loaded features: %d', Object.keys(this.feature).length)
+}
+
+export default collectFeature

package/lib/collect-schemas.js

@@ -0,0 +1,77 @@
+import path from 'path'
+import sanitizeSchema from './sanitize-schema.js'
+
+async function handler ({ file, alias, ns }) {
+  const { readConfig, pascalCase, eachPlugins } = this.app.bajo
+  const { isPlainObject, each, find, has, isArray, forOwn, isString, merge } = this.app.bajo.lib._
+  const { fastGlob } = this.app.bajo.lib
+
+  const defName = pascalCase(`${alias} ${path.basename(file, path.extname(file))}`)
+  const mod = await readConfig(file, { ns, ignoreError: true })
+  if (!isPlainObject(mod)) this.fatal('Invalid schema \'%s\'', defName)
+  mod.name = mod.name ?? defName
+  mod.modelName = mod.modelName ?? mod.name
+  if (!mod.connection) mod.connection = 'default'
+  mod.file = file
+  mod.ns = ns
+  mod.attachment = mod.attachment ?? true
+  mod.feature = mod.feature ?? []
+  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
+  if ((mod.properties ?? []).length === 0) this.fatal('Schema \'%s\' doesn\'t have properties at all', mod.name)
+  // schema extender
+  const me = this
+  await eachPlugins(async function (opts) {
+    const glob = `${opts.dir}/${me.name}/schema/extend/${mod.name}.*`
+    const files = await fastGlob(glob)
+    for (const file of files) {
+      const extender = await readConfig(file, { ns: opts.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 (opts.plugin === this.app.bajo.mainNs) {
+        each(['connection', 'modelName'], i => {
+          if (has(extender, i)) mod[i] = extender[i]
+        })
+      }
+      mod.extender = mod.extender ?? []
+      mod.extender.push(opts.plugin)
+    }
+  })
+  return mod
+}
+
+async function collectSchemas () {
+  const { eachPlugins } = this.app.bajo
+  const { isEmpty } = this.app.bajo.lib._
+  const result = await eachPlugins(handler, { glob: 'schema/*.*', baseNs: this.name })
+  if (isEmpty(result)) this.log.warn('No %s found!', this.print.write('schema'))
+  else await sanitizeSchema.call(this, result)
+}
+
+export default collectSchemas

package/lib/exec-feature-hook.js

@@ -0,0 +1,12 @@
+async function execFeatureHook (name, { schema, body } = {}) {
+  const { get } = this.app.bajo.lib._
+  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, { schema, body })
+  }
+}
+
+export default execFeatureHook

package/lib/exec-validation.js

@@ -0,0 +1,27 @@
+async function execValidation ({ noHook, name, body, options, partial }) {
+  const { runHook } = this.app.bajo
+  const { get, keys } = this.app.bajo.lib._
+  if (!noHook) {
+    await runHook(`${this.name}:onBeforeRecordValidation`, name, body, options)
+    await runHook(`${this.name}.${name}:onBeforeRecordValidation`, body, options)
+  }
+  const { validation = {} } = options
+  if (partial) {
+    validation.fields = keys(body)
+  }
+  try {
+    body = await this.validate(body, name, validation)
+  } catch (err) {
+    if (err.code === 'DB_VALIDATION' && get(options, 'req.flash')) {
+      options.req.flash('validation', err)
+    }
+    throw err
+  }
+  if (!noHook) {
+    await runHook(`${this.name}:onAfterRecordValidation`, name, body, options)
+    await runHook(`${this.name}.${name}:onAfterRecordValidation`, body, options)
+  }
+  return body
+}
+
+export default execValidation

package/lib/generic-prop-sanitizer.js

@@ -0,0 +1,38 @@
+const indexTypes = ['default', 'unique', 'primary', 'fulltext']
+
+async function genericPropSanitizer ({ prop, schema, driver }) {
+  const { join } = this.app.bajo
+  const { has, get, each } = this.app.bajo.lib._
+  const def = this.propType[prop.type]
+  // detect from drivers
+  /*
+  if (prop.name === 'id' && ['smallint', 'integer'].includes(prop.type) && driver.driver !== 'knex') {
+    fatal('Integer types of ID only supported by knex driver')
+  }
+  */
+  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, `defaults.property.${prop.type}.${p}`, def[p]))
+    if (def.choices && !def.choices.includes(prop[p])) {
+      this.fatal('Unsupported %s \'%s\' for \'%s@%s\'. Allowed choices: %s',
+        p, prop[p], prop.name, schema.name, join(def.choices))
+    }
+  })
+  if (prop.index && !indexTypes.includes(prop.index.type)) {
+    this.fatal('Unsupported index type %s for \'%s@%s\'. Allowed choices: %s',
+      prop.index.type, prop.name, schema.name, join(indexTypes))
+  }
+}
+
+export default genericPropSanitizer

package/lib/handle-attachment-upload.js

@@ -0,0 +1,16 @@
+async function handleAttachmentUpload ({ action, name, id, options = {} } = {}) {
+  const { getPluginDataDir } = this.app.bajo
+  const { fs } = this.app.bajo.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/merge-attachment-info.js

@@ -0,0 +1,16 @@
+async function mergeAttachmentInfo (rec, source, { mimeType, stats, fullPath }) {
+  const { importPkg } = this.app.bajo
+  const { fs } = this.app.bajo.lib
+  const { pick } = this.app.bajo.lib._
+  if (!this.bajoWeb) return
+  const mime = await importPkg('bajoWeb: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

@@ -0,0 +1,34 @@
+async function multiRelRows ({ schema, records, options = {} }) {
+  const { isSet } = this.app.bajo
+  const props = schema.properties.filter(p => isSet(p.rel))
+  const rels = {}
+  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 matches = records.map(r => r[prop.name])
+        const relschema = this.getSchema(val.schema)
+        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 })
+        }
+      }
+    }
+  }
+  return rels
+}
+
+export default multiRelRows

package/lib/resolve-method.js

@@ -0,0 +1,15 @@
+async function resolveMethod (name, method, options = {}) {
+  const { importModule } = this.app.bajo
+  const { fs } = this.app.bajo.lib
+  const { camelCase } = this.app.bajo.lib._
+  const { schema, driver, connection } = this.getInfo(name)
+  if (!options.force && (schema.disabled ?? []).includes(method)) throw this.error('Method \'%s@%s\' is disabled', camelCase(method), name)
+  const cfg = this.app[driver.ns].config
+  const [group, action] = method.split('-')
+  const file = `${cfg.dir.pkg}/${this.name}/method/${group}/${action}.js`
+  if (!fs.existsSync(file)) throw this.error('Method \'%s@%s\' is unsupported', camelCase(method), name)
+  const handler = await importModule(file)
+  return { handler, schema, driver, connection }
+}
+
+export default resolveMethod

package/lib/sanitize-schema.js

@@ -0,0 +1,180 @@
+import genericPropSanitizer from './generic-prop-sanitizer.js'
+
+async function sanitizeFeature (item) {
+  const { get, isPlainObject, mergeWith, isArray } = this.app.bajo.lib._
+  for (const f of item.feature) {
+    const feature = get(this.feature, f.name) // source from collectFeature
+    if (!feature) this.fatal('Unknown feature \'%s@%s\'', f.name, item.name)
+    let [ns, path] = f.name.split(':')
+    if (!path) ns = this.name
+    const input = await feature.call(this.app[ns], f)
+    let props = input.properties
+    if (isPlainObject(props)) props = [props]
+    if (props.length > 0) item.properties.push(...props)
+    item.globalRules = item.globalRules ?? []
+    if (input.globalRules) {
+      item.globalRules = mergeWith(item.globalRules, input.globalRules, (oval, sval) => {
+        if (isArray(oval)) return oval.concat(sval)
+      })
+    }
+  }
+}
+
+async function sanitizeIndexes (item) {
+  for (const idx of item.indexes) {
+    if (!(typeof idx.fields === 'string' || Array.isArray(idx.fields))) this.fatal('Only accept array of field names or single string of field name \'%s@%s\'', 'indexes', item.name)
+  }
+}
+
+async function sanitizeFullText (item) {
+  for (const f of item.fullText.fields ?? []) {
+    const prop = item.properties.find(p => p.name === f)
+    if (!prop) this.fatal('Invalid field name \'%s@%s\'', f, item.name)
+    // if (prop.type !== 'text') fatal.call(this, 'Fulltext index only available for field type \'text\' in \'%s@%s\'', f, item.name)
+  }
+}
+
+async function sanitizeSchema (items) {
+  const { freeze, fatal, importModule, defaultsDeep, join, breakNsPath } = this.app.bajo
+  const { map, keys, findIndex, find, each, isString, get, isPlainObject } = this.app.bajo.lib._
+  const properties = keys(this.propType)
+  const schemas = []
+  this.log.debug('Loading DB schemas')
+  for (const k in items) {
+    this.log.trace('- %s (%d)', k, keys(items[k]).length)
+    for (const f in items[k]) {
+      const item = items[k][f]
+      const conn = find(this.connections, { name: item.connection })
+      if (!conn) fatal.call(this, 'Unknown connection \'%s@%s\'', item.name, item.connection)
+      item.fullText = item.fullText ?? { fields: [] }
+      item.indexes = item.indexes ?? []
+      const [ns, type] = breakNsPath(conn.type)
+      const driver = find(this.drivers, { type, ns, driver: conn.driver })
+      if (driver.lowerCaseColl) item.modelName = item.modelName.toLowerCase()
+      let file = `${ns}:/${this.name}/lib/${type}/prop-sanitizer.js`
+      let propSanitizer = await importModule(file)
+      if (!propSanitizer) propSanitizer = genericPropSanitizer
+      for (const idx in item.properties) {
+        let prop = item.properties[idx]
+        if (isString(prop)) {
+          let [name, type, maxLength, index, required] = prop.split(':')
+          if (!type) type = 'string'
+          maxLength = maxLength ?? 255
+          prop = { name, type }
+          if (type === 'string') prop.maxLength = parseInt(maxLength) || undefined
+          if (index) prop.index = { type: index === 'true' ? 'default' : index }
+          prop.required = required === 'true'
+          item.properties[idx] = prop
+        } else {
+          if (isString(prop.index)) prop.index = { type: prop.index }
+          else if (prop.index === true) prop.index = { type: 'default' }
+        }
+      }
+      const idx = findIndex(item.properties, { name: 'id' })
+      if (idx === -1) item.properties.unshift(driver.idField)
+      item.feature = item.feature ?? []
+      await sanitizeFeature.call(this, item)
+      item.disabled = item.disabled ?? []
+      if (item.readonly) {
+        item.disabled = ['create', 'update', 'remove']
+        delete item.readonly
+      }
+      for (const idx in item.properties) {
+        let prop = item.properties[idx]
+        if (!prop.type) {
+          prop.type = 'string'
+          prop.maxLength = 255
+        }
+        if (!properties.includes(prop.type)) {
+          let success = false
+          const feature = get(this.feature, isPlainObject(prop.type) ? prop.type.name : prop.type)
+          if (feature) {
+            let opts = { fieldName: prop.name }
+            if (isPlainObject(prop.type)) opts = defaultsDeep(opts, prop.type)
+            else opts.name = prop.type
+            const feat = find(item.feature, opts)
+            if (!feat) item.feature.push(opts)
+            const input = await feature.call(this, opts)
+            if (input.properties && input.properties.length > 0) {
+              prop = input.properties[0]
+              success = true
+            }
+          }
+          if (!success) fatal.call(this, 'Unsupported property type \'%s@%s\' in \'%s\'', prop.type, prop.name, item.name)
+        }
+        if (prop.index) {
+          if (prop.index === 'unique') prop.index = { type: 'unique' }
+          else if (prop.index === 'fulltext') prop.index = { type: 'fulltext' }
+          else if (prop.index === 'primary') prop.index = { type: 'primary' }
+          else if (prop.index === true) prop.index = { type: 'default' }
+        }
+
+        await propSanitizer.call(this, { prop, schema: item, connection: conn, driver })
+        if (prop.index && prop.index.type === 'primary' && prop.name !== 'id') fatal.call(this, 'Primary index should only be used for \'id\' field')
+        if (prop.index && prop.index.type === 'fulltext') {
+          item.fullText.fields.push(prop.name)
+          prop.index.type = 'default'
+        }
+        item.properties[idx] = prop
+      }
+      await sanitizeIndexes.call(this, item)
+      await sanitizeFullText.call(this, item)
+      const all = []
+      each(item.properties, p => {
+        if (!all.includes(p.name)) all.push(p.name)
+        else fatal.call(this, 'Field \'%s@%s\' should be used only once', p.name, item.name)
+      })
+      file = `${ns}:/${this.name}/lib/${type}/schema-sanitizer.js`
+      const schemaSanitizer = await importModule(file)
+      if (schemaSanitizer) await schemaSanitizer.call(this, { schema: item, connection: conn, driver })
+      schemas.push(item)
+    }
+  }
+  for (const i in schemas) {
+    const schema = schemas[i]
+    for (const i2 in schema.properties) {
+      const prop = schema.properties[i2]
+      if (prop.type !== 'string') delete prop.maxLength
+      if (prop.rel) {
+        for (const key in prop.rel) {
+          let def = prop.rel[key]
+          if (isString(def)) {
+            const [rschema, rfield] = def.split(':')
+            def = { schema: rschema, propName: rfield }
+          }
+          def.type = def.type ?? 'one-to-one'
+          const rel = find(schemas, { name: def.schema })
+          if (!rel) {
+            fatal.call(this, 'No schema found for relationship \'%s@%s:%s\'', `${def.schema}:${def.propName}`, schema.name, prop.name)
+          }
+          const rprop = find(rel.properties, { name: def.propName })
+          if (!rprop) fatal.call(this, 'No property found for relationship \'%s@%s:%s\'', `${def.schema}:${def.propName}`, schema.name, prop.name)
+          def.fields = def.fields ?? []
+          if (['*', 'all'].includes(def.fields)) {
+            const relschema = find(schemas, { name: def.schema })
+            def.fields = relschema.properties.map(p => p.name)
+          }
+          if (def.fields.length > 0 && !def.fields.includes('id')) def.fields.push('id')
+          for (const f of def.fields) {
+            const p = find(rel.properties, { name: f })
+            if (!p) fatal.call(this, 'Unknown property for field \'%s\' in relationship \'%s@%s:%s\'', p, `${def.schema}:${def.propName}`, schema.name, prop.name)
+          }
+          prop.type = rprop.type
+          if (rprop.type === 'string') prop.maxLength = rprop.maxLength
+          else {
+            delete prop.maxLength
+            delete prop.minLength
+          }
+          prop.rel[key] = def
+        }
+        // TODO: propSanitizer must be called again
+      }
+      schema.properties[i2] = prop
+    }
+  }
+  this.schemas = schemas
+  freeze(this.schemas)
+  this.log.debug('Loaded schemas: %s', join(map(this.schemas, 'name')))
+}
+
+export default sanitizeSchema

package/lib/single-rel-rows.js

@@ -0,0 +1,32 @@
+async function singleRelRows ({ schema, record, options = {} }) {
+  const { isSet } = this.app.bajo
+  const props = schema.properties.filter(p => isSet(p.rel) && !(options.hidden ?? []).includes(p.name))
+  const rels = {}
+  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
+        const relschema = this.getSchema(val.schema)
+        const relFilter = options.filter
+        const query = {}
+        query[val.propName] = record[prop.name]
+        relFilter.query = query
+        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)
+        const data = []
+        for (const res of results) {
+          data.push(await this.pickRecord({ record: res, fields, schema: relschema }))
+        }
+        rels[key] = ['one-to-one'].includes(val.type) ? data[0] : data
+      }
+    }
+  }
+  record._rel = rels
+}
+
+export default singleRelRows

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dobo",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Database ORM/ODM for Bajo Framework",
   "main": "index.js",
   "scripts": {

package/waibuStatic/virtual.json

@@ -0,0 +1,4 @@
+[{
+  "prefix": "attachment",
+  "root": "data:/attachment"
+}]