dobo 2.0.1 → 2.2.0

package/lib/generic-prop-sanitizer.js

@@ -1,32 +0,0 @@
-const indexTypes = ['default', 'unique', 'primary', 'fulltext']
-
-async function genericPropSanitizer ({ prop, schema, driver }) {
-  const { join } = this.app.bajo
-  const { has, get, each } = this.app.lib._
-  const { propType } = this.app.pluginClass.dobo
-  const def = 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', 'textType'], 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.values && !def.values.includes(prop[p])) {
-      this.fatal('unsupportedAllowedChoices%s%s%s%s%s', p, prop[p], prop.name, schema.name, join(def.values))
-    }
-  })
-  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.app.lib
-  const { req, mimeType, stats, setFile, setField } = options
-
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  if (action === 'remove') {
-    const dir = `${getPluginDataDir(this.ns)}/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.app.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.app.lib
-  const { pick } = this.app.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.ns)}/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.syncPeriodDur)
-}
-
-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.app.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.app.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.app.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.app.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.app.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.app.lib
-  const { pick } = this.app.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.app.lib.aneka
-  const { uniq, find, map } = this.app.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.app.lib
-  const { camelCase } = this.app.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.ns}/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

package/lib/sanitize-schema.js

@@ -1,198 +0,0 @@
-import genericPropSanitizer from './generic-prop-sanitizer.js'
-
-async function sanitizeFeature (item) {
-  const { get, isPlainObject, mergeWith, isArray } = this.app.lib._
-  for (const f of item.feature) {
-    const feature = get(this.feature, f.name) // source from collectFeature
-    if (!feature) this.fatal('unknownFeature%s%s', f.name, item.name)
-    let [ns, path] = f.name.split('.')
-    if (!path) ns = this.ns
-    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) {
-  const { generateId } = this.app.bajo
-  for (const idx of item.indexes) {
-    if (!idx.name) idx.name = `${(item.modelName ?? item.name).toUpperCase()}_${generateId()}`
-    if (!(typeof idx.fields === 'string' || Array.isArray(idx.fields))) this.fatal('onlyAcceptFields%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('invalidFieldName%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 { defaultsDeep } = this.app.lib.aneka
-  const { freeze, fatal, importModule, join, breakNsPath, runHook } = this.app.bajo
-  const { isEmpty, orderBy, map, keys, findIndex, find, each, isString, get, isPlainObject, camelCase, uniq, filter } = this.app.lib._
-  const { propType } = this.app.pluginClass.dobo
-  const propTypes = keys(propType)
-  const schemas = []
-  this.log.debug('loadingDbSchemas')
-  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]
-      item.cacheable = item.cacheable ?? true
-      await runHook(`dobo.${camelCase(item.name)}:beforeSanitizeSchema`, item)
-      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 ?? []
-      let { ns, path: type } = breakNsPath(conn.type)
-      if (isEmpty(type)) type = conn.type
-      const driver = find(this.drivers, { type, ns, driver: conn.driver })
-      if (driver.lowerCaseModel) item.name = item.name.toLowerCase()
-      let file = `${ns}:/extend/${this.ns}/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 (!isEmpty(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.disabled === 'all') item.disabled = ['find', 'get', 'create', 'update', 'remove']
-      else if (item.disabled === 'readonly') item.disabled = ['create', 'update', 'remove']
-      for (const idx in item.properties) {
-        let prop = item.properties[idx]
-        if (!prop.type) {
-          prop.type = 'string'
-          prop.maxLength = 255
-        }
-        if (!propTypes.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}:/extend/${this.ns}/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]
-    const sortables = []
-    const hidden = []
-    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
-      }
-      if (prop.hidden) hidden.push(prop.name)
-      if (prop.index) sortables.push(prop.name)
-      delete prop.hidden
-      schema.properties[i2] = prop
-    }
-    // sortables
-    each(schema.indexes, item => {
-      sortables.push(...item.fields)
-    })
-    // hidden
-    schema.hidden = uniq(filter((schema.hidden ?? []).concat(hidden), item => map(schema.properties, 'name').includes(item)))
-    schema.sortables = sortables
-    await runHook(`dobo.${camelCase(schema.name)}:afterSanitizeSchema`, schema)
-  }
-  this.schemas = orderBy(schemas, ['buildLevel', 'name'])
-  freeze(this.schemas)
-  this.log.debug('loadedSchemas%s', join(map(this.schemas, 'name')))
-}
-
-export default sanitizeSchema

package/lib/single-rel-rows.js

@@ -1,38 +0,0 @@
-async function singleRelRows ({ schema, record, options = {} }) {
-  const { isSet } = this.app.lib.aneka
-  const { find } = this.app.lib._
-  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]
-        if (val.propName === 'id') {
-          const idField = find(relschema.properties, { name: 'id' })
-          if (idField.type === 'integer') query[val.propName] = parseInt(query[val.propName])
-        }
-
-        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/method/attachment/copy-uploaded.js

@@ -1,34 +0,0 @@
-import path from 'path'
-
-async function copyUploaded (name, id, options = {}) {
-  const { fs } = this.app.lib
-  const { req, setField, setFile, mimeType, stats, silent = true } = options
-  name = this.attachmentPreCheck(name)
-  if (!name) {
-    if (silent) return
-    throw this.error('isMissing%s', this.t('field.name'))
-  }
-  if (!this.app.waibu) {
-    if (silent) return
-    throw this.error('missingPlugin%s', 'Waibu')
-  }
-  const { dir, files } = await this.app.waibu.getUploadedFiles(req.id, false, true)
-  const result = []
-  if (files.length === 0) return result
-  for (const f of files) {
-    let [field, ...parts] = path.basename(f).split('@')
-    if (parts.length === 0) continue
-    field = setField ?? field
-    const file = setFile ?? parts.join('@')
-    const opts = { source: f, field, file, mimeType, stats, req, silent: true }
-    const rec = await this.attachmentCreate(name, id, opts)
-    if (!rec) continue
-    delete rec.dir
-    result.push(rec)
-    if (setField || setFile) break
-  }
-  fs.removeSync(dir)
-  return result
-}
-
-export default copyUploaded

package/method/attachment/create.js

@@ -1,29 +0,0 @@
-import mergeAttachmentInfo from '../../lib/merge-attachment-info.js'
-
-async function create (name, id, options = {}) {
-  const { fs } = this.app.lib
-  const { isEmpty } = this.app.lib._
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  const { source, field = 'file', file } = options
-  if (isEmpty(file)) return
-  if (!source) throw this.error('isMissing%s', this.t('field.source'))
-  const baseDir = await this.attachmentGetPath(name, id, field, file, { dirOnly: true })
-  const { fullPath, stats, mimeType, req } = options
-
-  let dir = `${baseDir}/${field}`
-  if ((field || '').endsWith('[]')) dir = `${baseDir}/${field.replace('[]', '')}`
-  const dest = `${dir}/${file}`.replaceAll('//', '/')
-  await fs.ensureDir(dir)
-  await fs.copy(source, dest)
-  const rec = {
-    field: field === '' ? undefined : field,
-    dir,
-    file
-  }
-  await mergeAttachmentInfo.call(this, rec, dest, { mimeType, fullPath, stats })
-  if (!options.silent && req && req.flash) req.flash('notify', req.t('attachmentUploaded'))
-  return rec
-}
-
-export default create

package/method/attachment/find.js

@@ -1,27 +0,0 @@
-import mergeAttachmentInfo from '../../lib/merge-attachment-info.js'
-
-async function find (name, id, options = {}) {
-  const { fastGlob, fs } = this.app.lib
-  const { getPluginDataDir } = this.app.bajo
-  name = this.attachmentPreCheck(name)
-  if (!name) return
-  const dir = `${getPluginDataDir(this.ns)}/attachment/${name}/${id}`
-  if (!fs.existsSync(dir)) return []
-  const files = await fastGlob(`${dir}/**/*`)
-  const { fullPath, stats, mimeType } = options
-  const recs = []
-  for (const f of files) {
-    const item = f.replace(dir, '')
-    let [, field, file] = item.split('/')
-    if (!file) {
-      file = field
-      field = null
-    }
-    const rec = { field, file }
-    await mergeAttachmentInfo.call(this, rec, f, { mimeType, fullPath, stats })
-    recs.push(rec)
-  }
-  return recs
-}
-
-export default find

package/method/attachment/get-path.js

@@ -1,12 +0,0 @@
-async function getPath (name, id, field, file, options = {}) {
-  const { getPluginDataDir } = this.app.bajo
-  const { pascalCase } = this.app.lib.aneka
-  const { fs } = this.app.lib
-  const dir = `${getPluginDataDir(this.ns)}/attachment/${pascalCase(name)}/${id}`
-  if (options.dirOnly) return dir
-  const path = field ? `${dir}/${field}/${file}` : `${dir}/${file}`
-  if (!fs.existsSync(path)) throw this.error('notFound')
-  return path
-}
-
-export default getPath