dobo 1.1.14 → 1.1.16

package/package.json

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

package/plugin/factory.js

@@ -5,6 +5,7 @@ import collectSchemas from '../lib/collect-schemas.js'
 import memDbStart from '../lib/mem-db/start.js'
 import memDbInstantiate from '../lib/mem-db/instantiate.js'
 import nql from '@tryghost/nql'
+import path from 'path'
 
 async function factory (pkgName) {
   const me = this
@@ -360,6 +361,34 @@ async function factory (pkgName) {
       if (fields.length === 0) return all
       return map(all, item => pick(item, fields))
     }
+
+    listAttachments = async ({ model, id = '*', field = '*', file = '*' } = {}, { uriEncoded = true } = {}) => {
+      const { map, kebabCase } = this.lib._
+      const { importPkg, getPluginDataDir, pascalCase } = this.app.bajo
+      const mime = await importPkg('waibu:mime')
+      const { fastGlob } = this.lib
+      const root = `${getPluginDataDir('dobo')}/attachment`
+      model = pascalCase(model)
+      let pattern = `${root}/${model}/${id}/${field}/${file}`
+      if (uriEncoded) pattern = pattern.split('/').map(p => decodeURI(p)).join('/')
+      return map(await fastGlob(pattern), f => {
+        const mimeType = mime.getType(path.extname(f)) ?? ''
+        const fullPath = f.replace(root, '')
+        const row = {
+          file: f,
+          fileName: path.basename(fullPath),
+          fullPath,
+          mimeType,
+          params: { model, id, field, file }
+        }
+        if (this.app.waibuMpa) {
+          const { routePath } = this.app.waibu
+          const [, _model, _id, _field, _file] = fullPath.split('/')
+          row.url = routePath(`dobo:/attachment/${kebabCase(_model)}/${_id}/${_field}/${_file}`)
+        }
+        return row
+      })
+    }
   }
 }
 

package/plugin/method/attachment/copy-uploaded.js

@@ -20,8 +20,9 @@ async function copyUploaded (name, id, options = {}) {
     if (parts.length === 0) continue
     field = setField ?? field
     const file = setFile ?? parts.join('@')
-    const opts = { source: f, field, file, mimeType, stats, req }
+    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

package/plugin/method/attachment/create.js

@@ -2,9 +2,11 @@ import mergeAttachmentInfo from '../../../lib/merge-attachment-info.js'
 
 async function create (name, id, options = {}) {
   const { fs } = this.lib
+  const { isEmpty } = this.lib._
   name = this.attachmentPreCheck(name)
   if (!name) return
-  const { source, field, file } = options
+  const { source, field = 'file', file } = options
+  if (isEmpty(file)) return
   if (!source) throw this.error('isMissing%s', this.print.write('field.source'))
   const baseDir = await this.attachmentGetPath(name, id, field, file, { dirOnly: true })
   const { fullPath, stats, mimeType, req } = options
@@ -20,7 +22,7 @@ async function create (name, id, options = {}) {
     file
   }
   await mergeAttachmentInfo.call(this, rec, dest, { mimeType, fullPath, stats })
-  if (req && req.flash) req.flash('notify', req.t('attachmentUploaded'))
+  if (!options.silent && req && req.flash) req.flash('notify', req.t('attachmentUploaded'))
   return rec
 }
 

package/plugin/method/record/create.js

@@ -56,13 +56,13 @@ async function create (name, input, opts = {}) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id: body.id, body, options, action: 'create' })
     if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordCreated'))
   }
+  if (clearModel) await clearModel({ model: name, body: nbody, options, record })
+  if (noResult) return
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordCreate`, nbody, options, record)
     await runHook(`${this.name}:afterRecordCreate`, name, nbody, options, record)
   }
-  if (clearModel) await clearModel({ model: name, body: nbody, options, record })
-  if (noResult) return
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterCreate', { schema, body: nbody, options, record })
   return dataOnly ? record.data : record
 }

package/plugin/method/record/find-one.js

@@ -39,11 +39,11 @@ async function findOne (name, filter = {}, opts = {}) {
   record.data = record.data[0]
 
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordFindOne`, filter, options, record)
     await runHook(`${this.name}:afterRecordFindOne`, name, filter, options, record)
   }
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (set && !noCache) await set({ model: name, filter, options, record })
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterFindOne', { schema, filter, options, record })
   return dataOnly ? record.data : record

package/plugin/method/record/find.js

@@ -36,13 +36,13 @@ async function find (name, filter = {}, opts = {}) {
   const records = options.records ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
   delete options.records
   if (isSet(options.rels)) await multiRelRows.call(this, { schema, records: records.data, options })
+  for (const idx in records.data) {
+    records.data[idx] = await this.pickRecord({ record: records.data[idx], fields, schema, hidden, forceNoHidden })
+  }
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordFind`, filter, options, records)
     await runHook(`${this.name}:afterRecordFind`, name, filter, options, records)
   }
-  for (const idx in records.data) {
-    records.data[idx] = await this.pickRecord({ record: records.data[idx], fields, schema, hidden, forceNoHidden })
-  }
   if (set && !noCache) await set({ model: name, filter, options, records })
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterFind', { schema, filter, options, records })
   return dataOnly ? records.data : records

package/plugin/method/record/get.js

@@ -33,12 +33,11 @@ async function get (name, id, opts = {}) {
   const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, options }))
   delete options.record
   if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, options })
+  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordGet`, id, options, record)
     await runHook(`${this.name}:afterRecordGet`, name, id, options, record)
   }
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
-
   if (set && !noCache) await set({ model: name, id, options, record })
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterGet', { schema, id, options, record })
   return dataOnly ? record.data : record

package/plugin/method/record/remove.js

@@ -27,13 +27,13 @@ async function remove (name, id, opts = {}) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, options, action: 'remove' })
     if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordRemoved'))
   }
+  if (clearModel) await clearModel({ model: name, id, options, record })
+  if (noResult) return
+  record.oldData = options.record ? options.record.oldData : (await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden }))
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordRemove`, id, options, record)
     await runHook(`${this.name}:afterRecordRemove`, name, id, options, record)
   }
-  if (clearModel) await clearModel({ model: name, id, options, record })
-  if (noResult) return
-  record.oldData = options.record ? options.record.oldData : (await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden }))
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterRemove', { schema, id, options, record })
   return dataOnly ? record.oldData : record
 }

package/plugin/method/record/update.js

@@ -47,14 +47,14 @@ async function update (name, id, input, opts = {}) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, body, options, action: 'update' })
     if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordUpdated'))
   }
-  if (!noHook) {
-    await runHook(`${this.name}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
-    await runHook(`${this.name}:afterRecordUpdate`, name, id, nbody, options, record)
-  }
   if (clearModel) await clearModel({ model: name, id, body: nbody, options, record })
   if (noResult) return
   record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
   record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
+  if (!noHook) {
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
+    await runHook(`${this.name}:afterRecordUpdate`, name, id, nbody, options, record)
+  }
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
   return dataOnly ? record.data : record
 }

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

@@ -1,25 +1,34 @@
 import path from 'path'
 
 async function attachment (req, reply) {
-  const { isString, isEmpty } = this.lib._
-  const { importPkg, getPluginDataDir, pascalCase } = this.app.bajo
+  const { isString, isEmpty, find } = this.lib._
+  const { pascalCase } = this.app.bajo
   const { routePath } = this.app.waibu
-  const mime = await importPkg('waibu:mime')
-  const { fs, fastGlob } = this.lib
-  let file = `${getPluginDataDir('dobo')}/attachment/${pascalCase(req.params.model)}/${req.params.id}/${req.params.field}/${req.params.file}`
-  if (path.basename(file) === '_first') {
-    const files = await fastGlob(`${path.dirname(file)}/*`)
-    if (files.length > 0) file = files[0]
+  const { fs } = this.lib
+  const items = await this.listAttachments({
+    model: req.params.model,
+    id: req.params.id,
+    field: req.params.field,
+    file: '*'
+  })
+  let item = req.params.file === '_first' ? items[0] : undefined
+  if (!item) {
+    item = find(items, i => {
+      const [, model, id, field, file] = i.fullPath.split('/')
+      return model === pascalCase(req.params.model) &&
+        id === decodeURI(req.params.id) &&
+        field === decodeURI(req.params.field) &&
+        file === decodeURI(req.params.file)
+    })
   }
-  const mimeType = mime.getType(path.extname(file)) ?? ''
-  if (!fs.existsSync(file)) {
+  if (!item) {
     if (!req.query.notfound) throw this.error('_notFound', { noContent: true })
-    const [, ext] = mimeType.split('/')
-    const replacer = isString(req.query.notfound) ? req.query.notfound : `waibuStatic.asset:/not-found.${ext ?? 'png'}`
+    const ext = path.extname(req.params.file)
+    const replacer = isString(req.query.notfound) ? req.query.notfound : `waibuStatic.asset:/not-found${isEmpty(ext) ? '.png' : ext}`
     return reply.redirectTo(routePath(replacer))
   }
-  if (!isEmpty(mimeType)) reply.header('Content-Type', mimeType)
-  const stream = fs.createReadStream(file)
+  if (!isEmpty(item.mimeType)) reply.header('Content-Type', item.mimeType)
+  const stream = fs.createReadStream(item.file)
   reply.send(stream)
   return reply
 }