dobo 2.35.0 → 2.36.0

package/lib/factory/model/sanitize-record.js

@@ -43,6 +43,14 @@ async function sanitizeRecord (record = {}, opts = {}) {
   if (opts.fmt) {
     newRecord._fmt = cloneDeep(newRecord)
     delete newRecord._fmt._ref
+    const options = {
+      lang: get(opts, 'intl.lang', get(opts, 'req.lang')),
+      timeZone: get(opts, 'intl.timeZone', get(opts, 'req.site.setting.bajo.intl.timeZone')),
+      emptyValue: get(opts, 'intl.emptyValue', get(opts, 'req.site.setting.bajo.intl.emptyValue')),
+      unitSys: get(opts, 'intl.unitSys', get(opts, 'req.site.setting.bajo.intl.unitSys')),
+      formatter: get(opts, 'intl.formatter', get(opts, 'req.site.setting.bajo.intl.formatter'))
+    }
+
     for (const key in newRecord) {
       const prop = this.getProperty(key)
       if (!prop) continue
@@ -56,19 +64,13 @@ async function sanitizeRecord (record = {}, opts = {}) {
       else if (isFunction(prop.format)) newRecord._fmt[key] = await prop.format.call(this, value, newRecord, opts)
       else if (isString(prop.format)) newRecord._fmt[key] = await callHandler(this.plugin, this, value, newRecord, opts)
       else {
-        const options = {
-          lang: get(opts, 'intl.lang', get(opts, 'req.lang')),
-          datetime: get(opts, 'intl.datetime', get(opts, 'req.site.setting.bajo.intl.datetime')),
-          date: get(opts, 'intl.date', get(opts, 'req.site.setting.bajo.intl.date')),
-          time: get(opts, 'intl.time', get(opts, 'req.site.setting.bajo.intl.time')),
-          timeZone: get(opts, 'intl.timeZone', get(opts, 'req.site.setting.bajo.intl.timeZone')),
-          emptyValue: get(opts, 'intl.emptyValue', get(opts, 'req.site.setting.bajo.intl.emptyValue')),
-          unitSys: get(opts, 'intl.unitSys', get(opts, 'req.site.setting.bajo.intl.unitSys')),
+        const _options = {
+          ...options,
+          field: key,
           latitude: ['lat', 'latitude'].includes(key),
-          longitude: ['lon', 'lng', 'longitude'].includes(key),
-          field: key
+          longitude: ['lon', 'lng', 'longitude'].includes(key)
         }
-        newRecord._fmt[key] = format(value, prop.type, options)
+        newRecord._fmt[key] = format(value, prop.type, _options)
       }
     }
   }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "dobo",
-  "version": "2.35.0",
+  "version": "2.36.0",
   "description": "DBMS for Bajo Framework",
   "main": "index.js",
   "scripts": {
     "build-doc": "jsdoc -c .jsdoc.conf.json",
-    "test": "mocha"
+    "test": "mocha --recursive"
   },
   "type": "module",
   "bajo": {
@@ -39,7 +39,9 @@
     "uuid": "^13.0.0"
   },
   "devDependencies": {
+    "chai": "^6.2.2",
     "clean-jsdoc-theme": "^4.3.0",
-    "jsdoc-plugin-intersection": "^1.0.4"
+    "jsdoc-plugin-intersection": "^1.0.4",
+    "mocha": "^11.7.6"
   }
 }

package/test/e2e/_run.js

@@ -0,0 +1,12 @@
+import { spawn } from 'node:child_process'
+
+export const runNodeInline = async (code, cwd) => {
+  return await new Promise((resolve) => {
+    const child = spawn(process.execPath, ['--input-type=module', '-e', code], { cwd, stdio: ['ignore', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.on('data', d => { stdout += d.toString() })
+    child.stderr.on('data', d => { stderr += d.toString() })
+    child.on('close', (exitCode) => resolve({ code: exitCode, stdout, stderr }))
+  })
+}

package/test/e2e/e2e-factory-process.test.js

@@ -0,0 +1,25 @@
+/* global describe, it */
+
+import { expect } from 'chai'
+import { runNodeInline } from './_run.js'
+
+describe('e2e factory process', () => {
+  it('builds dobo class and executes runtime methods in separate process', async function () {
+    this.timeout(10000)
+
+    const code = `
+import factory from './index.js'
+import { createAppStub } from './test/unit/_stub.js'
+const app = createAppStub('/tmp/dobo-e2e')
+const Dobo = await factory.call({ app }, 'dobo')
+const dobo = new Dobo()
+const rows = [{ g: 'a', n: 1 }, { g: 'a', n: 3 }]
+const agg = dobo.calcAggregate({ data: rows, group: 'g', field: 'n', aggregates: ['count', 'avg'] })
+console.log('E2E_OK:' + (Array.isArray(agg) && agg.length === 1 && agg[0].count === 2))
+`
+
+    const res = await runNodeInline(code, '/mnt/d/Projects/Dobo/dobo')
+    expect(res.code).to.equal(0)
+    expect(res.stdout).to.include('E2E_OK:true')
+  })
+})

package/test/e2e/e2e-model-adapter-process.test.js

@@ -0,0 +1,52 @@
+/* global describe, it */
+
+import { expect } from 'chai'
+import { runNodeInline } from './_run.js'
+
+describe('e2e model-adapter process', () => {
+  it('creates model and adapter classes and runs wrapper calls in separate process', async function () {
+    this.timeout(12000)
+
+    const code = `
+import adapterFactory from './lib/factory/adapter.js'
+import modelFactory from './lib/factory/model.js'
+import { createAppStub, Base } from './test/unit/_stub.js'
+
+const app = createAppStub('/tmp/dobo-e2e-model-adapter')
+app.bajo.runHook = async () => {}
+app.dobo = {
+  ns: 'dobo',
+  t: (x) => x,
+  error: (m) => new Error(m),
+  checkAggregateParams: () => {},
+  checkHistogramParams: () => {}
+}
+
+const plugin = new Base('dobo', app)
+plugin.error = (m) => new Error(m)
+await adapterFactory.call(plugin)
+await modelFactory.call(plugin)
+
+const adapter = new app.baseClass.DoboAdapter(plugin, 'memory')
+const conn = { name: 'default', adapter }
+const model = new app.baseClass.DoboModel(plugin, {
+  name: 'Order',
+  connection: conn,
+  properties: [{ name: 'id', type: 'string', maxLength: 50 }, { name: 'name', type: 'string' }],
+  indexes: [{ name: 'uidx_id', type: 'unique', fields: ['id'] }],
+  hooks: []
+})
+
+adapter.createRecord = async (m, body) => ({ data: { ...body } })
+adapter.getRecord = async (m, id) => ({ data: { _id: id, name: 'x' } })
+
+const created = await adapter._createRecord(model, { id: 'e1', name: 'ok' }, { noUniqueCheck: true, noIdCheck: true })
+const got = await adapter._getRecord(model, 'e1', {})
+console.log('E2E_MODEL_ADAPTER_OK:' + (created.data.id === 'e1' && got.data.id === 'e1'))
+`
+
+    const res = await runNodeInline(code, '/mnt/d/Projects/Dobo/dobo')
+    expect(res.code).to.equal(0)
+    expect(res.stdout).to.include('E2E_MODEL_ADAPTER_OK:true')
+  })
+})

package/test/integration/aspect-01-start-connections.test.js

@@ -0,0 +1,33 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { createAppStub } from '../unit/_stub.js'
+
+describe('integration aspect 01 - start connections', () => {
+  let dobo
+
+  beforeEach(async () => {
+    const app = createAppStub('/tmp/dobo-int-01')
+    const Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+  })
+
+  it('starts all, single, and selected connections', async () => {
+    const calls = []
+    const c1 = { name: 'primary', connect: async () => calls.push('primary'), adapter: { plugin: { ns: 'dobo' }, name: 'memory' } }
+    const c2 = { name: 'audit', connect: async () => calls.push('audit'), adapter: { plugin: { ns: 'dobo' }, name: 'memory' } }
+    dobo.connections = [c1, c2]
+
+    await dobo.start('all')
+    expect(calls).to.deep.equal(['primary', 'audit'])
+
+    calls.length = 0
+    await dobo.start('audit')
+    expect(calls).to.deep.equal(['audit'])
+
+    calls.length = 0
+    await dobo.start(['primary'])
+    expect(calls).to.deep.equal(['primary'])
+  })
+})

package/test/integration/aspect-02-query-regex.test.js

@@ -0,0 +1,34 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { createAppStub } from '../unit/_stub.js'
+
+describe('integration aspect 02 - query and regex', () => {
+  let dobo
+
+  beforeEach(async () => {
+    const app = createAppStub('/tmp/dobo-int-02')
+    const Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+  })
+
+  it('parses query text and preserves regex via json conversion', () => {
+    const model = {
+      scanables: ['title'],
+      sortables: ['title'],
+      properties: [{ name: 'title', type: 'string' }],
+      adapter: { idField: { name: '_id' } }
+    }
+
+    const q1 = dobo.parseQuery('title:~\'book\'', model)
+    expect(q1).to.be.an('object')
+
+    const q2 = dobo.parseQuery('{"id":"x"}', model)
+    expect(q2._id).to.equal('x')
+
+    const str = dobo.replaceRegexInJson({ title: /book/i })
+    const obj = dobo.reviveRegexInJson(str)
+    expect(obj.title).to.be.instanceOf(RegExp)
+  })
+})

package/test/integration/aspect-03-model-adapter-flow.test.js

@@ -0,0 +1,88 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import adapterFactory from '../../lib/factory/adapter.js'
+import modelFactory from '../../lib/factory/model.js'
+import { createAppStub, Base } from '../unit/_stub.js'
+
+describe('integration aspect 03 - model adapter flow', () => {
+  let app
+  let plugin
+  let model
+  let adapter
+  const store = {}
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-int-03')
+    app.bajo.runHook = async () => {}
+    app.dobo = {
+      ns: 'dobo',
+      t: (x) => x,
+      error: (msg, payload) => {
+        const err = new Error(msg)
+        err.payload = payload
+        return err
+      },
+      getDefaultValues: () => ({ warnings: true }),
+      checkAggregateParams: () => {},
+      checkHistogramParams: () => {}
+    }
+
+    plugin = new Base('dobo', app)
+    plugin.error = (msg, ...args) => new Error(`${msg}:${args.join(',')}`)
+    await adapterFactory.call(plugin)
+    await modelFactory.call(plugin)
+
+    adapter = new app.baseClass.DoboAdapter(plugin, 'memory')
+    const conn = { name: 'default', adapter }
+
+    model = new app.baseClass.DoboModel(plugin, {
+      name: 'Order',
+      connection: conn,
+      properties: [
+        { name: 'id', type: 'string', maxLength: 50 },
+        { name: 'name', type: 'string' },
+        { name: 'amount', type: 'double' },
+        { name: 'createdAt', type: 'datetime' }
+      ],
+      indexes: [{ name: 'uidx_id', type: 'unique', fields: ['id'] }],
+      hooks: []
+    })
+
+    adapter.getRecord = async (m, id) => ({ data: store[id] ? { ...store[id] } : null })
+    adapter.createRecord = async (m, body) => {
+      const key = body._id ?? body.id
+      store[key] = { ...body }
+      return { data: { ...body } }
+    }
+    adapter.updateRecord = async (m, id, body) => {
+      const oldData = { ...(store[id] ?? {}) }
+      store[id] = { ...(store[id] ?? {}), ...body }
+      return { oldData, data: { ...store[id] } }
+    }
+    adapter.findRecord = async () => ({ data: Object.values(store), count: Object.keys(store).length })
+    adapter.removeRecord = async (m, id) => {
+      const oldData = store[id] ? { ...store[id] } : null
+      delete store[id]
+      return { oldData }
+    }
+    adapter.clearRecord = async () => {
+      for (const k in store) delete store[k]
+      return { data: true }
+    }
+  })
+
+  it('executes create/find/update/remove lifecycle through adapter wrappers', async () => {
+    const c = await adapter._createRecord(model, { id: 'o1', name: 'book', amount: 10 }, { noUniqueCheck: true, noIdCheck: true })
+    expect(c.data.id).to.equal('o1')
+
+    const f = await adapter._findRecord(model, {}, {})
+    expect(f.count).to.equal(1)
+
+    const u = await adapter._updateRecord(model, 'o1', { amount: 15 }, { _data: { ...store.o1 } })
+    expect(u.data.amount).to.equal(15)
+
+    const r = await adapter._removeRecord(model, 'o1', { _data: { ...store.o1 } })
+    expect(r.oldData.id).to.equal('o1')
+  })
+})

package/test/unit/_stub.js

@@ -0,0 +1,244 @@
+import path from 'node:path'
+
+export const isPlainObject = (v) => Object.prototype.toString.call(v) === '[object Object]'
+
+export const camelCase = (s = '') => {
+  return String(s)
+    .replace(/^[\s_-]+|[\s_-]+$/g, '')
+    .split(/[\s_.-]+/)
+    .map((p, i) => i === 0 ? (p[0] ? p[0].toLowerCase() + p.slice(1) : '') : (p[0] ? p[0].toUpperCase() + p.slice(1) : ''))
+    .join('')
+}
+
+export const pascalCase = (s = '') => {
+  const cc = camelCase(s)
+  return cc[0] ? cc[0].toUpperCase() + cc.slice(1) : cc
+}
+
+export const find = (arr = [], matcher = {}) => {
+  if (typeof matcher === 'function') return arr.find(matcher)
+  return arr.find(item => Object.keys(matcher).every(k => item?.[k] === matcher[k]))
+}
+export const filter = (arr = [], matcher = {}) => {
+  if (typeof matcher === 'function') return arr.filter(matcher)
+  return arr.filter(item => Object.keys(matcher).every(k => item?.[k] === matcher[k]))
+}
+export const map = (arr = [], fn) => {
+  if (typeof fn === 'function') return arr.map(fn)
+  if (typeof fn === 'string') return arr.map(item => item?.[fn])
+  return [...arr]
+}
+export const pick = (obj = {}, keys = []) => keys.reduce((a, k) => { if (Object.prototype.hasOwnProperty.call(obj, k)) a[k] = obj[k]; return a }, {})
+export const groupBy = (arr = [], key) => arr.reduce((a, item) => { const k = item?.[key]; a[k] = a[k] ?? []; a[k].push(item); return a }, {})
+export const isEmpty = (v) => {
+  if (v === null || v === undefined) return true
+  if (typeof v === 'string') return v.trim() === ''
+  if (Array.isArray(v)) return v.length === 0
+  if (isPlainObject(v)) return Object.keys(v).length === 0
+  return false
+}
+export const uniq = (arr = []) => [...new Set(arr)]
+export const without = (arr = [], ...vals) => {
+  const flat = vals.flat()
+  return arr.filter(item => !flat.includes(item))
+}
+export const trim = (s = '') => String(s).trim()
+export const has = (obj, k) => Object.prototype.hasOwnProperty.call(obj ?? {}, k)
+export const keys = (obj = {}) => Object.keys(obj)
+export const defaults = (obj = {}, src = {}) => {
+  for (const k of Object.keys(src)) if (obj[k] === undefined) obj[k] = src[k]
+  return obj
+}
+export const isFunction = (v) => typeof v === 'function'
+export const kebabCase = (s = '') => String(s).replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[\s_.]+/g, '-').toLowerCase()
+export const chunk = (arr = [], size = 1) => {
+  const out = []
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size))
+  return out
+}
+export const last = (arr = []) => arr[arr.length - 1]
+export const forOwn = (obj = {}, fn) => {
+  for (const k of Object.keys(obj)) fn(obj[k], k)
+}
+export const findIndex = (arr = [], matcher = {}) => {
+  if (typeof matcher === 'function') return arr.findIndex(matcher)
+  return arr.findIndex(item => Object.keys(matcher).every(k => item?.[k] === matcher[k]))
+}
+export const omit = (obj = {}, drop = []) => {
+  const d = Array.isArray(drop) ? drop : [drop]
+  const out = {}
+  for (const k in obj) if (!d.includes(k)) out[k] = obj[k]
+  return out
+}
+export const cloneDeep = (obj) => JSON.parse(JSON.stringify(obj))
+export const pullAt = (arr = [], indexes = []) => {
+  const idxs = [...indexes].sort((a, b) => b - a)
+  for (const idx of idxs) if (Number.isInteger(idx) && idx >= 0 && idx < arr.length) arr.splice(idx, 1)
+  return arr
+}
+export const orderBy = (arr = [], fields = []) => {
+  const [field] = fields
+  return [...arr].sort((a, b) => {
+    if (a[field] === b[field]) return 0
+    return a[field] > b[field] ? 1 : -1
+  })
+}
+
+export const defaultsDeep = (...items) => {
+  const out = {}
+  const apply = (target, src) => {
+    if (!isPlainObject(src)) return target
+    for (const k of Object.keys(src)) {
+      const tv = target[k]
+      const sv = src[k]
+      if (isPlainObject(sv)) {
+        target[k] = apply(isPlainObject(tv) ? tv : {}, sv)
+      } else if (target[k] === undefined) {
+        target[k] = sv
+      }
+    }
+    return target
+  }
+  for (let i = 0; i < items.length; i++) apply(out, items[i])
+  return out
+}
+
+export const get = (obj, p, fallback) => {
+  const parts = String(p).split('.')
+  let cur = obj
+  for (const part of parts) {
+    if (cur == null) return fallback
+    cur = cur[part]
+  }
+  return cur === undefined ? fallback : cur
+}
+
+let gid = 0
+export const generateId = () => `id-${++gid}`
+export const isSet = (v) => v !== undefined && v !== null
+
+export class Base {
+  constructor (pkgName, app) {
+    this.pkgName = pkgName
+    this.app = app
+    this.ns = camelCase(pkgName)
+    this.alias = this.ns
+    this.log = {
+      trace: () => {},
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {}
+    }
+  }
+
+  t = (text) => text
+
+  error = (msg, ...args) => new Error(`${msg}:${args.join(',')}`)
+
+  getConfig = (pathLike) => get(this.config, pathLike)
+}
+
+export class Tools {
+  constructor (plugin) {
+    this.plugin = plugin
+    this.app = plugin.app
+  }
+
+  async dispose () {
+    this.plugin = null
+    this.app = null
+  }
+
+  bindThis (...fns) {
+    for (const fn of fns) {
+      if (!fn?.name) continue
+      this[fn.name] = fn.bind(this)
+    }
+  }
+}
+
+export const createAppStub = (root = '/tmp/dobo-test') => {
+  const app = {
+    dir: root,
+    t: (text) => text,
+    lib: {
+      _: {
+        find,
+        filter,
+        isString: (v) => typeof v === 'string',
+        isArray: Array.isArray,
+        isFunction,
+        map,
+        get,
+        pick,
+        groupBy,
+        isEmpty,
+        isNaN: Number.isNaN,
+        trim,
+        isPlainObject,
+        uniq,
+        without,
+        defaults,
+        findIndex,
+        chunk,
+        last,
+        forOwn,
+        kebabCase,
+        keys,
+        has,
+        camelCase,
+        isNumber: (v) => typeof v === 'number' && !Number.isNaN(v),
+        omit,
+        cloneDeep,
+        pullAt,
+        orderBy
+      },
+      aneka: {
+        pascalCase,
+        camelCase,
+        defaultsDeep,
+        generateId,
+        isSet
+      },
+      dayjs: (value) => {
+        const d = value instanceof Date ? value : new Date(value)
+        return {
+          isValid: () => !Number.isNaN(d.getTime()),
+          toDate: () => new Date(d.getTime()),
+          format: (pattern) => {
+            const y = d.getUTCFullYear()
+            const m = String(d.getUTCMonth() + 1).padStart(2, '0')
+            const day = String(d.getUTCDate()).padStart(2, '0')
+            if (pattern === 'YYYY-MM-DD') return `${y}-${m}-${day}`
+            if (pattern === 'YYYY-MM') return `${y}-${m}`
+            if (pattern === 'YYYY') return `${y}`
+            return d.toISOString()
+          }
+        }
+      },
+      fs: {
+        ensureDirSync: () => {}
+      }
+    },
+    baseClass: {
+      Base,
+      Tools
+    },
+    bajo: {
+      breakNsPath: (v) => {
+        const i = v.indexOf(':')
+        return i === -1 ? { ns: v, path: '' } : { ns: v.slice(0, i), path: v.slice(i + 1) }
+      },
+      join: (arr = []) => arr.join(', '),
+      runHook: async () => {},
+      eachPlugins: async () => {},
+      buildCollections: async () => [],
+      importModule: async () => {},
+      callHandler: async (scope, handler, ...args) => typeof handler === 'function' ? handler.call(scope, ...args) : undefined,
+      readConfig: async () => ({})
+    },
+    getPluginDataDir: (name) => path.join(root, 'plugins', name)
+  }
+  return app
+}

package/test/unit/dobo-action.test.js

@@ -0,0 +1,58 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import actionFactory from '../../lib/factory/action.js'
+import { createAppStub } from './_stub.js'
+
+describe('dobo action class (unit)', () => {
+  let app
+  let plugin
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-action')
+    plugin = { app }
+    await actionFactory.call(plugin)
+  })
+
+  it('creates chainable action class and runs model handlers', async () => {
+    const calls = []
+    const model = {
+      plugin,
+      getRecord: async (...args) => {
+        calls.push(args)
+        return { ok: true }
+      }
+    }
+
+    const action = new app.baseClass.DoboAction(model, 'getRecord', 'abc')
+    const resp = await action
+      .noHook()
+      .dataOnly(false)
+      .run({ noCache: false })
+
+    expect(resp.ok).to.equal(true)
+    expect(calls).to.have.length(1)
+    expect(calls[0][0]).to.equal('abc')
+    expect(calls[0][1]).to.be.an('object')
+  })
+
+  it('builder methods for create/update payload set expected positional args', async () => {
+    const model = {
+      plugin,
+      updateRecord: async (id, body, options) => ({ id, body, options })
+    }
+
+    const action = new app.baseClass.DoboAction(model)
+    const result = await action.updateRecord('id-1', { name: 'A' }).run()
+    expect(result.id).to.equal('id-1')
+    expect(result.body.name).to.equal('A')
+  })
+
+  it('dispose clears action references', async () => {
+    const model = { plugin, getRecord: async () => ({}) }
+    const action = new app.baseClass.DoboAction(model, 'getRecord', 'x')
+    await action.dispose()
+    expect(action.model).to.equal(null)
+    expect(action._options).to.equal(null)
+  })
+})

package/test/unit/dobo-connection.test.js

@@ -0,0 +1,37 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import connectionFactory from '../../lib/factory/connection.js'
+import { createAppStub } from './_stub.js'
+
+describe('dobo connection class (unit)', () => {
+  let app
+  let plugin
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-connection')
+    app.baseClass.DoboNullAdapter = class DoboNullAdapter {}
+    app.baseClass.DoboAdapter = class DoboAdapter {}
+    plugin = {
+      app,
+      getAdapter: () => ({ sanitizeConnection: async () => {}, connect: async () => ({ client: true }) })
+    }
+    await connectionFactory.call(plugin)
+  })
+
+  it('creates DoboConnection, initializes adapter and connects', async () => {
+    const conn = new app.baseClass.DoboConnection(plugin, { name: 'default', adapter: 'dobo:memory', models: ['User'] })
+    await conn.initAdapter('dobo:memory')
+    expect(conn.adapter).to.be.an('object')
+    await conn.connect(true)
+    expect(conn.connected).to.equal(true)
+    expect(conn.client).to.deep.equal({ client: true })
+  })
+
+  it('dispose clears adapter reference', async () => {
+    const conn = new app.baseClass.DoboConnection(plugin, { name: 'default', adapter: 'dobo:memory' })
+    conn.adapter = { ok: true }
+    await conn.dispose()
+    expect(conn.adapter).to.equal(null)
+  })
+})

package/test/unit/dobo-core.test.js

@@ -0,0 +1,136 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { createAppStub } from './_stub.js'
+
+describe('dobo core class (unit)', () => {
+  let app
+  let Dobo
+  let dobo
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-unit')
+    Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+  })
+
+  it('creates plugin class with expected static values and defaults', () => {
+    expect(Dobo.aggregateTypes).to.include('count')
+    expect(Dobo.histogramTypes).to.include('yearly')
+    expect(Dobo.idTypes).to.include('string')
+    expect(dobo.config.default.filter.limit).to.equal(25)
+    expect(dobo.adapters).to.deep.equal([])
+    expect(dobo.connections).to.deep.equal([])
+    expect(dobo.features).to.deep.equal([])
+    expect(dobo.models).to.deep.equal([])
+  })
+
+  it('property key helpers include type-specific fields', () => {
+    expect(dobo.getPropertyKeysByType('string')).to.include('maxLength')
+    expect(dobo.getPropertyKeysByType('text')).to.include('textType')
+    expect(dobo.getPropertyKeysByType('smallint')).to.include('autoInc')
+
+    const keys = dobo.getAllPropertyKeys({ constructor: { propertyKeys: ['xFlag'] } })
+    expect(keys).to.include('name')
+    expect(keys).to.include('validator')
+    expect(keys).to.include('xFlag')
+  })
+
+  it('connection, adapter, feature and model lookups work', () => {
+    dobo.connections = [{ name: 'default' }, { name: 'report' }]
+    expect(dobo.getConnection('report').name).to.equal('report')
+    expect(dobo.getConnection('none', true)).to.equal(undefined)
+
+    dobo.adapters = [
+      { name: 'memory', plugin: { ns: 'dobo' } },
+      { name: 'proxy', plugin: { ns: 'ext' } }
+    ]
+    expect(dobo.getAdapter('memory').name).to.equal('memory')
+    expect(dobo.getAdapter('ext:proxy').name).to.equal('proxy')
+    expect(dobo.getAdapter('missing', true)).to.equal(undefined)
+
+    dobo.features = [{ name: 'createdAt', plugin: { ns: 'dobo' } }]
+    expect(dobo.getFeature('createdAt').name).to.equal('createdAt')
+
+    dobo.models = [{ name: 'Order' }, { name: 'Customer' }]
+    expect(dobo.getModel('Order').name).to.equal('Order')
+    expect(dobo.getModel('order').name).to.equal('Order')
+    expect(dobo.getModel('none', true)).to.equal(undefined)
+  })
+
+  it('sanitize helpers and aggregate calculators work', () => {
+    expect(dobo.sanitizeBoolean('true')).to.equal(true)
+    expect(dobo.sanitizeBoolean(false)).to.equal(false)
+    expect(dobo.sanitizeFloat('12.4')).to.equal(12.4)
+    expect(dobo.sanitizeInt('12')).to.equal(12)
+    expect(dobo.sanitizeString(44)).to.equal('44')
+    expect(dobo.sanitizeObject('{"a":1}')).to.deep.equal({ a: 1 })
+
+    const rows = [
+      { grp: 'a', price: 10 },
+      { grp: 'a', price: 30 },
+      { grp: 'b', price: 20 }
+    ]
+    const agg = dobo.calcAggregate({ data: rows, group: 'grp', field: 'price', aggregates: ['count', 'avg', 'min', 'max'] })
+    expect(agg).to.have.length(2)
+    const itemA = agg.find(i => i.grp === 'a')
+    expect(itemA.count).to.equal(2)
+    expect(itemA.max).to.equal(30)
+  })
+
+  it('histogram and query parsers work with valid input', () => {
+    const rows = [
+      { createdAt: '2026-01-01T00:00:00Z', score: 5 },
+      { createdAt: '2026-01-01T12:00:00Z', score: 7 },
+      { createdAt: '2026-01-02T00:00:00Z', score: 10 }
+    ]
+    const hist = dobo.calcHistogram({ data: rows, type: 'daily', group: 'createdAt', field: 'score', aggregates: ['count'] })
+    expect(hist).to.have.length(2)
+    expect(hist[0]).to.have.property('date')
+
+    const model = {
+      scanables: ['name'],
+      sortables: ['name'],
+      properties: [{ name: 'name', type: 'string' }],
+      adapter: { idField: { name: '_id' } }
+    }
+    const parsed = dobo.parseQuery('name:~\'john\'', model)
+    expect(parsed).to.be.an('object')
+
+    const parsedAny = dobo.parseQuery('john*', model)
+    expect(parsedAny).to.be.an('object')
+  })
+
+  it('regex json helpers and model hooks work', async () => {
+    const input = { n: /abc/gi }
+    const text = dobo.replaceRegexInJson(input, true)
+    const revived = dobo.reviveRegexInJson(text, true)
+    expect(revived.n).to.be.instanceOf(RegExp)
+    expect(revived.n.flags).to.include('g')
+
+    const calls = []
+    const model = {
+      hooks: [
+        { name: 'beforeCreateRecord', level: 2, handler: async () => calls.push(2) },
+        { name: 'beforeCreateRecord', level: 1, handler: async () => calls.push(1) }
+      ]
+    }
+    await dobo.runModelHook(model, 'beforeCreateRecord', {})
+    expect(calls).to.deep.equal([1, 2])
+  })
+
+  it('default values and hard-cap last page handler work', () => {
+    dobo.config.default.filter = { limit: 10, maxLimit: 50, maxPage: 30, sort: [] }
+    dobo.config.default.hardCap = 100
+    dobo.config.default.warnings = true
+
+    const def = dobo.getDefaultValues()
+    expect(def.limit).to.equal(10)
+    expect(def.hardCap).to.equal(100)
+
+    const result = dobo.handleLastPage({ count: 300, limit: 10, page: 25 })
+    expect(result.count).to.equal(100)
+    expect(result.data).to.deep.equal([])
+  })
+})

package/test/unit/dobo-feature.test.js

@@ -0,0 +1,25 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import featureFactory from '../../lib/factory/feature.js'
+import { createAppStub } from './_stub.js'
+
+describe('dobo feature class (unit)', () => {
+  let app
+  let plugin
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-feature')
+    plugin = { app }
+    await featureFactory.call(plugin)
+  })
+
+  it('creates DoboFeature and disposes cleanly', async () => {
+    const feat = new app.baseClass.DoboFeature(plugin, { name: 'createdAt', handler: async () => ({}) })
+    expect(feat.name).to.equal('createdAt')
+    expect(feat.handler).to.be.a('function')
+    await feat.dispose()
+    expect(feat.name).to.equal(null)
+    expect(feat.handler).to.equal(null)
+  })
+})

package/test/unit/dobo-model.test.js

@@ -0,0 +1,115 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import modelFactory from '../../lib/factory/model.js'
+import { createAppStub, Base } from './_stub.js'
+
+describe('dobo model class (unit)', () => {
+  let app
+  let plugin
+  let model
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-model-unit')
+    app.dobo = {
+      models: [],
+      sanitizeDate: (v) => v,
+      sanitizeByType: (v) => v,
+      checkAggregateParams: () => {},
+      checkHistogramParams: () => {},
+      runModelHook: async () => {},
+      parseQuery: (q) => q
+    }
+    app.baseClass.DoboAction = class DoboAction {
+      constructor (m, name, ...args) {
+        this.model = m
+        this.name = name
+        this.args = args
+      }
+    }
+
+    plugin = new Base('dobo', app)
+    await modelFactory.call(plugin)
+
+    const options = {
+      name: 'Order',
+      baseName: 'order',
+      connection: {
+        name: 'default',
+        adapter: { idField: { name: '_id', type: 'string', maxLength: 50 } }
+      },
+      properties: [
+        { name: 'id', type: 'string', maxLength: 50 },
+        { name: 'title', type: 'string', maxLength: 50 },
+        { name: 'total', type: 'double' },
+        { name: 'virtualTitle', type: 'string', virtual: true }
+      ],
+      indexes: [{ name: 'idx_title', type: 'index', fields: ['title'] }],
+      hooks: []
+    }
+    model = new app.baseClass.DoboModel(plugin, options)
+    app.dobo.models.push(model)
+  })
+
+  it('builds aliases, action and property getters correctly', () => {
+    const act = model.action('getRecord', 'id-1')
+    expect(act.name).to.equal('getRecord')
+    expect(model.getProperty('title').type).to.equal('string')
+    expect(model.getField('title').name).to.equal('title')
+    expect(model.hasProperty('title')).to.equal(true)
+    expect(model.hasField('ghost')).to.equal(false)
+    expect(model.getIndexes()).to.have.length(1)
+  })
+
+  it('returns filtered property lists (all, virtual, non-virtual)', () => {
+    expect(model.getProperties().length).to.equal(4)
+    expect(model.getProperties({ noVirtual: true }).length).to.equal(3)
+    expect(model.getProperties({ noVirtual: true, namesOnly: true })).to.include('title')
+    expect(model.getVirtualProperties(true)).to.deep.equal(['virtualTitle'])
+    expect(model.getNonVirtualProperties(true)).to.include('id')
+  })
+
+  it('sanitizes and syncs id field', () => {
+    model.properties[0].type = 'integer'
+    expect(model.sanitizeId('12')).to.equal(12)
+
+    model.syncIdField({ name: 'id', type: 'string', maxLength: 20 })
+    expect(model.properties[0].maxLength).to.equal(20)
+  })
+
+  it('buildPropValues supports array and req translation hooks', async () => {
+    const prop = {
+      name: 'status',
+      values: ['draft', { value: 'done', text: 'done' }]
+    }
+    const req = {
+      te: (k) => k === 'statusDone',
+      t: () => 'Selesai'
+    }
+    const vals = await model.buildPropValues(prop, { req })
+    expect(vals).to.have.length(2)
+    expect(vals[1].text).to.equal('Selesai')
+  })
+
+  it('_simpleLookup handles string/object/array definitions', async () => {
+    const userModel = {
+      findOneRecord: async () => ({ id: 'u1', username: 'john' })
+    }
+    app.dobo.getModel = () => userModel
+
+    const a = await model._simpleLookup('User:username:id=u1', {})
+    expect(a).to.equal('john')
+
+    const b = await model._simpleLookup({ model: 'User', field: 'id', query: 'id={id}' }, { id: 'u9' })
+    expect(b).to.equal('u1')
+
+    const c = await model._simpleLookup(['User', 'id', 'id=u5'], {})
+    expect(c).to.equal('u1')
+  })
+
+  it('dispose clears connection and adapter references', async () => {
+    await model.dispose()
+    expect(model.connection).to.equal(null)
+    expect(model.adapter).to.equal(null)
+  })
+})

package/test/unit/helper-sanitize-all.test.js

@@ -0,0 +1,40 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { sanitizeAll } from '../../lib/helper.js'
+import { createAppStub } from './_stub.js'
+
+describe('helper sanitizeAll (unit)', () => {
+  let app
+  let dobo
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-helper-all')
+    const Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+    app.dobo = dobo
+    dobo.fatal = (msg, ...args) => { throw new Error(`${msg}:${args.join(',')}`) }
+  })
+
+  it('normalizes properties, indexes, sortables and hidden fields', async () => {
+    const schema = {
+      name: 'Order',
+      properties: [
+        { name: 'id', type: 'string', index: 'primary' },
+        { name: 'name', type: 'string', minLength: '0', maxLength: '20' },
+        { name: 'amount', type: 'double' }
+      ],
+      indexes: [{ name: 'idx_name', type: 'index', fields: ['name'] }],
+      hidden: ['name', 'ghost']
+    }
+
+    await sanitizeAll.call(dobo, schema)
+
+    expect(schema.sortables).to.include('name')
+    expect(schema.hidden).to.deep.equal(['name'])
+    const nameProp = schema.properties.find(p => p.name === 'name')
+    expect(nameProp.maxLength).to.equal(20)
+    expect(nameProp.minLength).to.equal(undefined)
+  })
+})

package/test/unit/helper-sanitize-ref.test.js

@@ -0,0 +1,64 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import factory from '../../index.js'
+import { sanitizeRef } from '../../lib/helper.js'
+import { createAppStub } from './_stub.js'
+
+describe('helper sanitizeRef (unit)', () => {
+  let app
+  let dobo
+
+  beforeEach(async () => {
+    app = createAppStub('/tmp/dobo-helper-ref')
+    const Dobo = await factory.call({ app }, 'dobo')
+    dobo = new Dobo()
+    app.dobo = dobo
+    dobo.fatal = (msg, ...args) => { throw new Error(`${msg}:${args.join(',')}`) }
+  })
+
+  it('normalizes reference fields and filters unknown refs', async () => {
+    const user = {
+      name: 'User',
+      properties: [{ name: 'id' }, { name: 'name' }]
+    }
+    const order = {
+      name: 'Order',
+      properties: [
+        {
+          name: 'userId',
+          ref: {
+            user: { model: 'User', field: 'id', fields: ['name'] },
+            missing: { model: 'Unknown', field: 'id' }
+          }
+        }
+      ]
+    }
+
+    await sanitizeRef.call(dobo, order, [user, order])
+
+    expect(order.properties[0].ref.user.type).to.equal('1:1')
+    expect(order.properties[0].ref.user.searchField).to.equal('id')
+    expect(order.properties[0].ref.user.labelField).to.equal('id')
+    expect(order.properties[0].ref.user.fields).to.include('id')
+    expect(order.properties[0].ref.missing).to.equal(undefined)
+  })
+
+  it('throws when duplicate ref keys exist across properties', async () => {
+    const schema = {
+      name: 'Order',
+      properties: [
+        { name: 'a', ref: { rel: { model: 'User' } } },
+        { name: 'b', ref: { rel: { model: 'User' } } }
+      ]
+    }
+    const user = { name: 'User', properties: [{ name: 'id' }] }
+
+    let err
+    try {
+      await sanitizeRef.call(dobo, schema, [schema, user])
+    } catch (e) { err = e }
+    expect(err).to.be.instanceOf(Error)
+    expect(err.message).to.include('duplicateRefKeys')
+  })
+})

package/wiki/CHANGES.md

@@ -1,5 +1,10 @@
 # Changes
 
+## 2026-07-31
+
+- [2.36.0] Add test suite
+- [2.36.0] Add parameter `options` to `model.sanitizeRecord()`
+
 ## 2026-07-29
 
 - [2.35.0] Add parameter `options` to `adapter.sanitizeRecord()` to allow passing additional options for sanitization