waibu-db 2.16.0 → 2.16.2

package/extend/waibuBootstrap/theme/component/wdb-base.js

@@ -1,50 +1,5 @@
 async function wdbBase () {
   return class WdbBase extends this.app.baseClass.MpaWidget {
-    constructor (options) {
-      super(options)
-      const { getModel } = this.app.dobo
-      const { get } = this.app.lib._
-      this.schema = get(this, 'component.locals.schema', {})
-      this.formData = get(this, 'component.locals.form', {})
-      this.oldData = get(this, 'component.locals.oldData', {})
-      this.model = getModel(this.schema.name, true)
-    }
-
-    getRef = ({ field, refName, returning } = {}) => {
-      const { get } = this.app.lib._
-      if (!this.model) return {}
-      const prop = this.model.getProperty(field)
-      if (!prop) return {}
-      if (!refName && field.endsWith('Id')) refName = field.slice(0, -2)
-      const key = this.params.attr.refName ?? refName
-      const ref = get(prop, `ref.${key}`, {})
-      if (returning === 'all') return { ref, key }
-      else if (returning === 'key') return key
-      return ref
-    }
-
-    getRefValue = ({ field, data, labelField, refName } = {}) => {
-      const { get, isEmpty } = this.app.lib._
-      const { ref, key } = this.getRef({ field, refName, returning: 'all' })
-      if (isEmpty(ref)) return undefined
-      labelField = labelField ?? ref.labelField ?? 'id'
-      return (get(data ?? this.formData, `_ref.${key}.${labelField}`))
-    }
-
-    getRefName = (field) => {
-      const { get } = this.app.lib._
-      let refName = get(this.schema, `view.widget.${field}.attr.ref-name`, this.params.attr.refName)
-      if (!refName && this.params.attr[field] && this.params.attr[field].endsWith('Id')) refName = this.params.attr[field].slice(0, -2)
-      return refName
-    }
-
-    getSetting = (key, defValue) => {
-      const { get, camelCase } = this.app.lib._
-      const widgetName = camelCase(this.constructor.name)
-      key = key.replaceAll('{self}', widgetName)
-      const cfg = this.app.waibu.getSetting(`${this.plugin.ns}:${key}`, { defValue, req: this.component.req })
-      return get(this.schema, `view.${key}`, cfg)
-    }
   }
 }
 

package/extend/waibuBootstrap/theme/component/widget/btn-export.js

@@ -67,16 +67,13 @@ async function btnExport () {
             let items = []
             let checker = false
             const keys = []
-            const types = []
             let els = document.querySelectorAll(selector + ' thead th')
             for (const el of els) {
               keys.push(this.options.includes('fkey') ? el.innerText : el.dataset.key)
-              types.push(el.dataset.type)
             }
             if (_.isEmpty(keys[0])) {
               checker = true
               keys.shift()
-              types.shift()
             }
             els = document.querySelectorAll(selector + ' tbody tr')
             for (const el of els) {
@@ -85,12 +82,7 @@ async function btnExport () {
                 i = i + ''
                 if (i === '0' && checker) return undefined
                 if (this.options.includes('fvalue')) data.push(v.innerText)
-                else {
-                  const type = types[parseInt(i)]
-                  let val = wmpa.parseValue(v.dataset.value, type)
-                  if (['datetime', 'date', 'time'].includes(type)) val = val.toISOString()
-                  data.push(val)
-                }
+                else data.push(wmpa.parseValue(v.dataset.value, v.dataset.value))
               })
               const item = {}
               for (const i in keys) {

package/extend/waibuBootstrap/theme/component/widget/form.js

@@ -1,58 +1,24 @@
 import wdbBase from '../wdb-base.js'
 
-async function handleRo (attr = {}, prop = {}, widget = {}) {
-  const { get, camelCase, isEmpty, isString } = this.app.lib._
-  const { callHandler } = this.app.bajo
-  const { escape } = this.app.waibu
-  const { req } = this.component
-  const dataValue = get(this.formData, `_orig.${prop.name}`, prop.dataValue ?? '')
-  let value = get(this.oldData, prop.name, get(this.formData, prop.name, prop.value ?? ''))
-  const format = get(this.schema, `view.format.${prop.name}`)
-  const formatValue = get(this.schema, `view.formatValue.${prop.name}`)
-  const labelField = get(this.schema, `view.widget.${prop.name}.attr.labelField`)
-  if (formatValue) value = await formatValue.call(this, value, this.formData, { req })
-  else if (prop.ref) {
-    value = this.getRefValue({ field: prop.name, labelField, refName: this.getRefName(prop.name) })
-    if (format && !isEmpty(value)) attr.href = await format.call(this, value, this.formData, { linkOnly: true })
-  } else if (prop.values) {
-    const values = isString(prop.values) ? (await callHandler(prop.values)) : prop.values
-    value = values.find(v => v.value === dataValue)
-    if (value) {
-      const key = camelCase(`${prop.name} ${value.text}`)
-      value = req.te(key) ? req.t(key) : value.text
-    }
-  } else if (format && !isEmpty(value)) value = await format.call(this, value, this.formData)
-  attr.dataValue = escape(dataValue)
-  attr.value = escape(value)
-  attr.dataType = prop.type
-
-  if (['object', 'array', 'text'].includes(prop.type)) {
-    attr.style = 'min-height: 100px'
-    return await this.component.buildTag({ tag: 'formTextarea', attr, html: value })
-  }
-  return await this.component.buildTag({ tag: 'formPlaintext', attr, selfCosing: true, noEscape: true })
-}
-
-async function handleRw (attr = {}, prop = {}, widget = {}) {
-  const { get, has, isPlainObject, isArray } = this.app.lib._
-  const { escape } = this.app.waibu
-  const { stringifyAttribs } = this.app.waibuMpa
-  if (has(attr, 'name') && !has(attr, 'value')) {
-    attr.dataType = attr.dataType ?? prop.type
-    attr.dataValue = get(this, `formData.${attr.name}`)
-    if (isPlainObject(attr.dataValue) || isArray(attr.dataValue)) attr.dataValue = JSON.stringify(attr.dataValue)
-    attr.dataValue = escape(attr.dataValue)
-    attr.value = widget.component === 'form-plaintext' ? get(this, `oldData.${attr.name}`, attr.dataValue) : attr.dataValue
-  }
-
-  const cmp = prop.ref ? 'wdb-lookup-select' : widget.component
-  return `<c:${cmp} ${stringifyAttribs(attr)} data-type="${prop.type}" />`
-}
-
 async function form () {
   const WdbBase = await wdbBase.call(this)
 
   return class WdbForm extends WdbBase {
+    static async handleRo ({ attr = {}, prop = {} } = {}) {
+      return await this.component.buildTag({ tag: 'formPlaintext', attr, selfCosing: true, noEscape: true })
+    }
+
+    static async handleRw ({ attr = {}, prop = {}, widget = {} } = {}) {
+      const { get, has } = this.app.lib._
+      const { stringifyAttribs } = this.app.waibuMpa
+      if (has(attr, 'name') && !has(attr, 'value')) {
+        attr.value = widget.component === 'form-plaintext' ? get(this, `oldData.${attr.name}`, attr.dataValue) : attr.dataValue
+      }
+      attr.dataType = prop.type
+      const cmp = prop.ref ? 'wdb-lookup-select' : widget.component
+      return `<c:${cmp} ${stringifyAttribs(attr)} />`
+    }
+
     build = async () => {
       const { get, find, filter, forOwn, isEmpty } = this.app.lib._
       const { base64JsonEncode } = this.app.waibu
@@ -85,9 +51,9 @@ async function form () {
           }
           if (widget.componentOpts) attr['c-opts'] = base64JsonEncode(widget.componentOpts)
           if (widget.component === 'form-plaintext' || this.params.attr.method !== 'POST') {
-            body.push(await handleRo.call(this, attr, prop, widget))
+            body.push(await WdbForm.handleRo.call(this, { attr, prop, widget }))
           } else {
-            body.push(await handleRw.call(this, attr, prop, widget))
+            body.push(await WdbForm.handleRw.call(this, { attr, prop, widget }))
           }
         }
         body.push('</c:fieldset>')

package/extend/waibuBootstrap/theme/component/widget/table.js

@@ -4,8 +4,6 @@ async function table () {
   const WdbBase = await wdbBase.call(this)
 
   return class WdbTable extends WdbBase {
-    propValues = {}
-
     isRightAligned = (field, schema) => {
       const { get, find } = this.app.lib._
       const prop = find(schema.properties, { name: field })
@@ -22,11 +20,10 @@ async function table () {
     }
 
     build = async () => {
-      const { callHandler } = this.app.bajo
       const { req } = this.component
       const { escape, attrToArray } = this.app.waibu
       const { groupAttrs } = this.app.waibuMpa
-      const { get, omit, set, find, isEmpty, without, merge, camelCase } = this.app.lib._
+      const { get, omit, set, find, isEmpty, without, merge } = this.app.lib._
       const group = groupAttrs(this.params.attr, ['body', 'head', 'foot'])
       this.params.attr = group._
       const prettyUrl = this.params.attr.prettyUrl
@@ -35,11 +32,6 @@ async function table () {
       const data = get(this, 'component.locals.list.data', [])
       const filter = get(this, 'component.locals.list.filter', {})
       const count = get(this, 'component.locals.list.count', 0)
-      // collect prop.values for later use
-      for (const prop of schema.properties) {
-        if (typeof prop.values === 'string') this.propValues[prop.name] = await callHandler(prop.values)
-        else if (prop.values) this.propValues[prop.name] = prop.values
-      }
       if (count === 0 || data.length === 0) {
         const alert = '<c:alert color="warning" t:content="noRecordFound" margin="top-4"/>'
         this.params.noTag = true
@@ -134,12 +126,10 @@ async function table () {
           let prop = find(schema.properties, { name: f })
           if (!prop) prop = find(schema.view.calcFields, { name: f })
           if (!prop) continue
-          let dataValue = d._orig[f] ?? ''
-          if (!isEmpty(dataValue)) {
-            if (['datetime'].includes(prop.type)) dataValue = escape(dataValue.toISOString())
-            if (['string', 'text'].includes(prop.type)) dataValue = escape(dataValue)
-            if (['array', 'object'].includes(prop.type)) dataValue = escape(JSON.stringify(d[f]))
-          }
+          let dataValue = d._orig[f]
+          if (['datetime'].includes(prop.type)) dataValue = escape(dataValue.toISOString())
+          else if (['string', 'text'].includes(prop.type)) dataValue = escape(dataValue)
+          else if (['array', 'object'].includes(prop.type)) dataValue = escape(JSON.stringify(d[f]))
           const refName = get(schema, `view.widget.${f}.attr.refName`)
           let value = this.getRefValue({ field: f, data: d, refName }) ?? d[f]
           const formatValue = get(schema, `view.formatValue.${f}`)
@@ -154,21 +144,9 @@ async function table () {
           if (formatCell) merge(attr, await formatCell.call(this, value, d, { params: this.params, req }))
           const noWrap = this.isNoWrap(f, schema, group.body.nowrap) ? 'nowrap' : ''
           if (this.isRightAligned(f, schema)) attr.text = `align:end ${noWrap}`
-          else attr.text = noWrap
-          const lookup = get(schema, `view.lookup.${f}`)
-          if (lookup) {
-            const item = find(lookup.values, set({}, lookup.id ?? 'id', dataValue))
-            if (item) value = req.t(item[lookup.field ?? 'name'])
-          }
+          else attr.text = `${noWrap}`
           const format = get(schema, `view.format.${f}`)
           if (format) value = await format.call(this, value, d, { params: this.params, req })
-          if (this.propValues[f]) {
-            const item = find(this.propValues[f], { value: dataValue })
-            if (item) {
-              const key = camelCase(`${f} ${item.text}`)
-              value = req.te(key) ? req.t(key) : item.text
-            }
-          }
           const line = await this.component.buildTag({ tag: 'td', attr, html: value })
           lines.push(line)
         }

package/lib/method/create-record.js

@@ -1,11 +1,11 @@
 import { prepCrud, processHandler } from '../util.js'
 
-async function createRecord ({ model, req, reply, body, options = {}, transaction } = {}) {
-  const { model: mdl, input, opts, attachment, stats, mimeType } = await prepCrud.call(this, { model, req, reply, body, options, args: ['model'], transaction })
+async function createRecord ({ model, req, reply, options = {}, transaction } = {}) {
+  const { model: mdl, opts, attachment, stats, mimeType } = await prepCrud.call(this, { model, req, reply, options, args: ['model'], transaction })
 
   async function handler (trx) {
     if (opts.trx === true) opts.trx = trx
-    const ret = await mdl.createRecord(input, opts)
+    const ret = await mdl.createRecord(req.body, { ...opts, partial: true, strict: true })
     if (attachment) ret.data._attachment = await mdl.findAttachment(ret.data.id, { stats, mimeType })
     return ret
   }

package/lib/method/update-record.js

@@ -1,7 +1,7 @@
 import { prepCrud, getOneRecord, processHandler } from '../util.js'
 
 async function updateRecord ({ model, req, reply, id, body, options = {}, transaction } = {}) {
-  const { model: mdl, filter, input, opts, recId, attachment, stats, mimeType } = await prepCrud.call(this, { model, req, reply, body, id, options, args: ['model', 'id'], transaction })
+  const { model: mdl, filter, opts, recId, attachment, stats, mimeType } = await prepCrud.call(this, { model, req, reply, id, options, args: ['model', 'id'], transaction })
   const me = this
 
   async function handler (trx) {
@@ -10,7 +10,7 @@ async function updateRecord ({ model, req, reply, id, body, options = {}, transa
       const resp = await getOneRecord.call(me, mdl, recId, filter, opts)
       opts._data = resp.data
     }
-    const ret = await mdl.updateRecord(recId, input, opts)
+    const ret = await mdl.updateRecord(recId, body ?? req.body, { ...opts, partial: true, strict: true })
     if (attachment) ret.data._attachment = await mdl.findAttachment(id, { stats, mimeType })
     return ret
   }

package/lib/util.js

@@ -1,6 +1,6 @@
 export const actions = ['countRecord', 'createAggregate', 'createHistogram', 'createRecord', 'findAllRecord', 'findOneRecord', 'findRecord', 'getRecord', 'removeRecord', 'updateRecord']
 
-export async function prepCrud ({ model, body, id, req, reply, transaction, options = {}, args } = {}) {
+export async function prepCrud ({ model, id, req, reply, transaction, options = {}, args } = {}) {
   const { isSet } = this.app.lib.aneka
   const { importModule } = this.app.bajo
   const { parseFilter } = this.app.waibu
@@ -42,8 +42,6 @@ export async function prepCrud ({ model, body, id, req, reply, transaction, opti
     model = model ?? pascalCase(params.model)
     mdl = this.app.dobo.getModel(model)
   }
-  const input = await mdl.sanitizeBody({ body: body ?? params.body, partial: true, strict: true })
-
   opts.bboxLatField = req.query[cfgWeb.qsKey.bboxLatField]
   opts.bboxLngField = req.query[cfgWeb.qsKey.bboxLngField]
   const filter = parseFilter(req)
@@ -54,7 +52,7 @@ export async function prepCrud ({ model, body, id, req, reply, transaction, opti
   if (options.limit) filter.limit = options.limit
   if (options.sort) filter.sort = options.sort
   if (options.page) filter.page = options.page
-  return { model: mdl, recId, input, opts, filter, attachment, stats, mimeType }
+  return { model: mdl, recId, opts, filter, attachment, stats, mimeType }
 }
 
 export async function getOneRecord (model, id, filter, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waibu-db",
-  "version": "2.16.0",
+  "version": "2.16.2",
   "description": "DB Helper",
   "main": "index.js",
   "scripts": {

package/wiki/CHANGES.md

@@ -1,5 +1,20 @@
 # Changes
 
+## 2026-04-17
+
+- [2.16.2] Bug fix in ```WdbTable``` widget
+- [2.16.2] Bug fix in ```WdbForm``` widget
+- [2.16.2] Remove reduncat codes in ```WdbBase``` widget
+
+## 2026-04-16
+
+- [2.16.1] Bug fix in ```WdbBtnExport``` widget
+- [2.16.1] Bug fix in ```WdbForm``` widget
+- [2.16.1] Bug fix in ```WdbTable``` widget
+- [2.16.1] Bug fix in ```prepCrud()```
+- [2.16.1] Bug fix in ```createRecord()```
+- [2.16.1] Bug fix in ```updateRecord()```
+
 ## 2026-04-13
 
 - [2.16.0] Add ```oldData``` propety to ```WdbBase``` widget