dobo 2.2.4 → 2.3.0

package/extend/dobo/feature/unique.js

@@ -0,0 +1,30 @@
+import crypto from 'crypto'
+
+async function unique (opts = {}) {
+  const { omit } = this.app.lib._
+  opts.fieldName = opts.fieldName ?? 'id'
+  opts.fields = opts.fields ?? []
+  return {
+    properties: [{
+      name: opts.fieldName,
+      type: 'string',
+      maxLength: 32,
+      required: true,
+      index: 'primary'
+    }],
+    hooks: [{
+      name: 'beforeCreateRecord',
+      level: 1000,
+      handler: async function (body, options) {
+        if (opts.fields.length === 0) opts.fields = omit(this.properties.map(prop => prop.name), [opts.fieldName])
+        const item = {}
+        for (const f of opts.fields) {
+          item[f] = body[f]
+        }
+        body[opts.fieldName] = crypto.createHash('md5').update(JSON.stringify(item)).digest('hex')
+      }
+    }]
+  }
+}
+
+export default unique

package/lib/collect-models.js

@@ -65,8 +65,12 @@ async function findAllProps (model, inputs = [], indexes = [], isExtender) {
  * @param {Object} options - Options to the feature
  * @returns {Array} New properties found in feature
  */
-async function applyFeature (model, feature, options, indexes) {
-  const { isArray } = this.app.lib._
+async function applyFeature (model, feature, options, indexes, isExtender) {
+  const { isArray, findIndex } = this.app.lib._
+  if (feature.name === 'dobo:unique' && options.fieldName === 'id') {
+    const idx = findIndex(model.properties, { name: 'id' })
+    if (idx > -1) model.properties.pullAt(idx)
+  }
   const item = await feature.handler(options)
   if (item.rules) model.rules.push(...item.rules)
   if (!isArray(item.properties)) item.properties = [item.properties]
@@ -88,14 +92,14 @@ async function applyFeature (model, feature, options, indexes) {
  * @param {Object} model - Model
  * @param {Array} [inputs] - Array of properties
  */
-async function findAllFeats (model, inputs = [], indexes = []) {
+async function findAllFeats (model, inputs = [], indexes = [], isExtender) {
   const { isString, omit } = this.app.lib._
   for (let feat of inputs) {
     if (isString(feat)) feat = { name: feat }
     const featName = feat.name.indexOf(':') === -1 ? `dobo:${feat.name}` : feat.name
     const feature = this.app.dobo.getFeature(featName)
     if (!feature) this.fatal('invalidFeature%s%s', model.name, featName)
-    await applyFeature.call(this, model, feature, omit(feat, 'name'), indexes)
+    await applyFeature.call(this, model, feature, omit(feat, 'name'), indexes, isExtender)
   }
 }
 
@@ -307,7 +311,6 @@ async function collectModels () {
     const idProp = schema.properties.find(p => p.name === 'id')
     if (!this.constructor.idTypes.includes(idProp.type)) this.fatal('invalidIdType%s%s', schema.name, this.constructor.idTypes.join(', '))
     if (idProp.type === 'string' && !has(idProp, 'maxLength')) idProp.maxLength = 50
-    // schema.properties = without(schema.properties, undefined)
     const model = new DoboModel(plugin, schema)
     me.models.push(model)
   }

package/lib/factory/driver.js

@@ -1,6 +1,6 @@
-import crypto from 'crypto'
 import { ulid } from 'ulid'
 import { v4 as uuidv4, v7 as uuidv7 } from 'uuid'
+import crypto from 'crypto'
 
 const defIdField = {
   name: '_id',
@@ -48,6 +48,7 @@ async function driverFactory () {
      * @param {Object} conn - Connection object
      */
     async sanitizeConnection (conn) {
+      conn.proto = conn.proto ?? 'http' // used by driver that use url based connection
       conn.memory = false
     }
 
@@ -155,42 +156,47 @@ async function driverFactory () {
 
     async _createRecord (model, body = {}, options = {}) {
       const { isSet, generateId } = this.app.lib.aneka
-      const { pick, isFunction } = this.app.lib._
-      const prop = model.properties.find(p => p.name === 'id')
-      if (!isSet(body.id) && prop.type === 'string') {
-        if (options.checksumId) {
-          if (options.checksumId === true) options.checksumId = Object.keys(body)
-          const checksum = pick(body, options.checksumId)
-          body.id = crypto.createHash('md5').update(JSON.stringify(checksum)).digest('hex')
-        } else if (this.idGenerator) {
-          if (['uuid', 'uuidv4'].includes(this.idGenerator)) body.id = uuidv4()
-          else if (['uuidv7'].includes(this.idGenerator)) body.id = uuidv7()
-          else if (this.idGenerator === 'generateId') body.id = generateId()
-          else if (isFunction(this.idGenerator)) body.id = await this.idGenerator(model, body, options)
-        }
-        if (!body.id) body.id = ulid()
-        body.id = body.id.slice(0, prop.maxLength)
-      }
-      if (!this.uniqueIndexSupport) await this._checkUnique(model, body, options)
+      const { isFunction } = this.app.lib._
       for (const prop of model.properties) {
         if (!isSet(body[prop.name]) && isSet(prop.default)) {
           if (isFunction(prop.default)) body[prop.name] = await prop.default.call(model)
-          else if (typeof prop.default === 'string') {
-            if (['now()', 'current_timestamp()'].includes(prop.default.toLowerCase()) && ['datetime', 'date', 'timestamp'].includes(prop.type)) {
+          else if (typeof prop.default !== 'string') body[prop.name] = prop.default
+          else {
+            if (['now'].includes(prop.default) && prop.type === 'datetime') {
               body[prop.name] = new Date()
-            } else if (['uuid()', 'uuidv4()'].includes(prop.default.toLowerCase()) && prop.type === 'string') {
+            } else if (['uuid', 'uuidv4'].includes(prop.default) && prop.type === 'string') {
               body[prop.name] = uuidv4().slice(0, prop.maxLength)
-            } else if (['uuidv7()'].includes(prop.default.toLowerCase()) && prop.type === 'string') {
+            } else if (prop.default === 'uuidv7' && prop.type === 'string') {
               body[prop.name] = uuidv7().slice(0, prop.maxLength)
-            } else if (['ulid()'].includes(prop.default.toLowerCase()) && prop.type === 'string') {
+            } else if (prop.default === 'ulid' && prop.type === 'string') {
               body[prop.name] = ulid().slice(0, prop.maxLength)
-            } else if (prop.default.toLowerCase() === 'generateId' && prop.type === 'string') {
+            } else if (prop.default === 'generateid' && prop.type === 'string') {
               body[prop.name] = generateId()
+            } else if (prop.default.startsWith('md5:') && prop.type === 'string') {
+              const [, field] = prop.default.split(':')
+              const fields = field.split(',')
+              if (model.properties.filter(item => fields.includes(item.name)).length === fields.length) {
+                const values = fields.map(f => body[f])
+                body[prop.name] = crypto.createHash('md5').update(values.join(':')).digest('hex')
+              }
+            } else {
+              body[prop.name] = prop.default
             }
           }
-          body[prop.name] = isFunction(prop.default) ? await prop.default.call(model) : prop.default
         }
       }
+      const prop = model.properties.find(p => p.name === 'id')
+      if (!isSet(body.id) && prop.type === 'string') {
+        if (this.idGenerator) {
+          if (['uuid', 'uuidv4'].includes(this.idGenerator)) body.id = uuidv4()
+          else if (['uuidv7'].includes(this.idGenerator)) body.id = uuidv7()
+          else if (this.idGenerator === 'generateId') body.id = generateId()
+          else if (isFunction(this.idGenerator)) body.id = await this.idGenerator(model, body, options)
+        }
+        if (!body.id) body.id = ulid()
+        body.id = body.id.slice(0, prop.maxLength)
+      }
+      if (!this.uniqueIndexSupport) await this._checkUnique(model, body, options)
       if (isSet(body.id)) {
         const resp = await this.getRecord(model, body.id, { noHook: true })
         if (!isEmpty(resp.data)) throw this.plugin.error('recordExists%s%s', body.id, model.name)

package/lib/factory/model/_util.js

@@ -13,13 +13,28 @@ export async function execHook (name, ...args) {
 }
 
 export async function execModelHook (name, ...args) {
-  const { last } = this.app.lib._
+  const { last, orderBy } = this.app.lib._
   const { noModelHook } = last(args)
   const results = []
   if (!noModelHook) {
-    const hooks = this.hooks.filter(hook => hook.name === name)
+    const hooks = orderBy(this.hooks.filter(hook => hook.name === name), ['level'])
     for (const hook of hooks) {
-      await hook.handler.call(this, ...args)
+      if (hook.noWait) hook.handler.call(this, ...args)
+      else await hook.handler.call(this, ...args)
+    }
+  }
+  return results
+}
+
+export async function execDynHook (name, ...args) {
+  const { last, orderBy } = this.app.lib._
+  const opts = last(args)
+  const results = []
+  if (!opts.noDynHook) {
+    const hooks = orderBy((opts.dynHooks ?? []).filter(hook => hook.name === name), ['level'])
+    for (const hook of hooks) {
+      if (hook.noWait) hook.handler.call(this, ...args)
+      else await hook.handler.call(this, ...args)
     }
   }
   return results
@@ -142,6 +157,7 @@ export async function handleAttachmentUpload (id, trigger, options = {}) {
 
 export async function getSingleRef (record = {}, options = {}) {
   const { isSet } = this.app.lib.aneka
+  const { get } = this.app.lib._
   const props = this.properties.filter(p => isSet(p.ref) && !(options.hidden ?? []).includes(p.name))
   const refs = {}
   options.refs = options.refs ?? []
@@ -151,6 +167,7 @@ export async function getSingleRef (record = {}, options = {}) {
         if (!((typeof options.refs === 'string' && ['*', 'all'].includes(options.refs)) || options.refs.includes(key))) continue
         const ref = prop.ref[key]
         if (ref.fields.length === 0) continue
+        if (get(record, `_ref.${key}`)) continue
         const rModel = this.app.dobo.getModel(ref.model)
         const query = {}
         query[ref.propName] = record[prop.name]
@@ -172,7 +189,7 @@ export async function getSingleRef (record = {}, options = {}) {
 
 export async function getMultiRefs (records = [], options = {}) {
   const { isSet } = this.app.lib.aneka
-  const { uniq, map } = this.app.lib._
+  const { uniq, map, get } = this.app.lib._
   const props = this.properties.filter(p => isSet(p.ref) && !(options.hidden ?? []).includes(p.name))
   options.refs = options.refs ?? []
   if (props.length > 0) {
@@ -182,6 +199,7 @@ export async function getMultiRefs (records = [], options = {}) {
         const ref = prop.ref[key]
         if (ref.fields.length === 0) continue
         if (ref.type !== '1:1') continue
+        if (get(records, `0._ref.${key}`)) continue
         const rModel = this.app.dobo.getModel(ref.model)
         const matches = uniq(map(records, r => {
           let v = r[prop.name]

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
 const action = 'clearRecord'
 
 async function clearRecord (...args) {
@@ -8,7 +8,9 @@ async function clearRecord (...args) {
   const { options } = await getFilterAndOptions.call(this, null, opts, action)
   await execHook.call(this, 'beforeClearRecord', options)
   await execModelHook.call(this, 'beforeClearRecord', options)
+  await execDynHook.call(this, 'beforeClearRecord', options)
   const result = (await this.driver._clearRecord(this, options)) ?? {}
+  await execDynHook.call(this, 'beforeClearRecord', result, options)
   await execModelHook.call(this, 'afterClearRecord', result, options)
   await execHook.call(this, 'afterClearRecord', result, options)
   return dataOnly ? result.data : result

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
 const action = 'countRecord'
 
 async function countRecord (...args) {
@@ -8,7 +8,9 @@ async function countRecord (...args) {
   const { filter, options } = await getFilterAndOptions.call(this, params, opts, action)
   await execHook.call(this, 'beforeCountRecord', options)
   await execModelHook.call(this, 'beforeCountRecord', filter, options)
+  await execDynHook.call(this, 'beforeCountRecord', filter, options)
   const result = (await this.driver._countRecord(this, filter, options)) ?? {}
+  await execDynHook.call(this, 'afterCountRecord', filter, result, options)
   await execModelHook.call(this, 'afterCountRecord', filter, result, options)
   await execHook.call(this, 'afterCountRecord', filter, result, options)
   return dataOnly ? result.data : result

package/lib/factory/model/create-aggregate.js

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
 const action = 'createAggregate'
 
 async function createAggregate (...args) {
@@ -8,7 +8,9 @@ async function createAggregate (...args) {
   const { filter, options } = await getFilterAndOptions.call(this, _filter, opts, action)
   await execHook.call(this, 'beforeCreateAggregate', filter, params, options)
   await execModelHook.call(this, 'beforeCreateAggregate', filter, params, options)
+  await execDynHook.call(this, 'beforeCreateAggregate', filter, params, options)
   const result = (await this.driver._createAggregate(this, filter, params, options)) ?? {}
+  await execDynHook.call(this, 'afterCreateAggregate', filter, params, result, options)
   await execModelHook.call(this, 'afterCreateAggregate', filter, params, result, options)
   await execHook.call(this, 'afterCreateAggregate', filter, params, result, options)
   return dataOnly ? result.data : result

package/lib/factory/model/create-histogram.js

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook } from './_util.js'
 const action = 'createHistogram'
 
 async function createHistogram (...args) {
@@ -8,7 +8,9 @@ async function createHistogram (...args) {
   const { filter, options } = await getFilterAndOptions.call(this, _filter, opts, action)
   await execHook.call(this, 'beforeCreateHistogram', filter, params, options)
   await execModelHook.call(this, 'beforeCreateHistogram', filter, params, options)
+  await execDynHook.call(this, 'beforeCreateHistogram', filter, params, options)
   const result = (await this.driver._createHistogram(this, filter, params, options)) ?? {}
+  await execDynHook.call(this, 'afterCreateHistogram', filter, params, result, options)
   await execModelHook.call(this, 'afterCreateHistogram', filter, params, result, options)
   await execHook.call(this, 'afterCreateHistogram', filter, params, result, options)
   return dataOnly ? result.data : result

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getSingleRef, handleReq } from './_util.js'
 
 export const onlyTypes = ['datetime', 'date', 'time', 'timestamp']
 const action = 'createRecord'
@@ -16,6 +16,7 @@ async function createRecord (...args) {
   const input = noBodySanitizer ? cloneDeep(body) : await this.sanitizeBody({ body, extFields, strict: true, truncateString, onlyTypes })
   await execHook.call(this, 'beforeCreateRecord', input, options)
   await execModelHook.call(this, 'beforeCreateRecord', input, options)
+  await execDynHook.call(this, 'beforeCreateRecord', input, options)
   if (!noValidation) await execValidation.call(this, input, options)
   let result = options.record ?? (await this.driver._createRecord(this, input, options)) ?? {}
   if (noResult) {
@@ -26,6 +27,7 @@ async function createRecord (...args) {
   if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
   if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
   await handleReq.call(this, result.data.id, 'created', options)
+  await execDynHook.call(this, 'afterCreateRecord', input, result, options)
   await execModelHook.call(this, 'afterCreateRecord', input, result, options)
   await execHook.call(this, 'afterCreateRecord', input, result, options)
   await runHook('cache:clear', this, 'create', body, result)

package/lib/factory/model/find-all-record.js

@@ -1,4 +1,4 @@
-import { getMultiRefs, execHook, execModelHook, getFilterAndOptions } from './_util.js'
+import { getMultiRefs, execHook, execModelHook, execDynHook, getFilterAndOptions } from './_util.js'
 const action = 'findAllRecord'
 
 async function native (filter, options, dataOnly) {
@@ -9,6 +9,7 @@ async function native (filter, options, dataOnly) {
   if (!this.cacheable) noCache = true
   await execHook.call(this, 'beforeFindAllRecord', filter, options)
   await execModelHook.call(this, 'beforeFindAllRecord', filter, options)
+  await execDynHook.call(this, 'beforeFindAllRecord', filter, options)
   if (get && !noCache && !options.record) {
     const cachedResult = await get({ model: this.name, filter, options })
     if (cachedResult) {
@@ -24,6 +25,7 @@ async function native (filter, options, dataOnly) {
     }
   }
   if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
+  await execDynHook.call(this, 'beforeCreateRecord', filter, result, options)
   await execModelHook.call(this, 'afterFindAllRecord', filter, result, options)
   await execHook.call(this, 'afterFindAllRecord', filter, result, options)
   if (set && !noCache) await set({ model: this.name, filter, options, result })

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, getMultiRefs } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getMultiRefs } from './_util.js'
 const action = 'findRecord'
 
 /**
@@ -87,6 +87,7 @@ async function findRecord (...args) {
   }
   await execHook.call(this, 'beforeFindRecord', filter, options)
   await execModelHook.call(this, 'beforeFindRecord', filter, options)
+  await execDynHook.call(this, 'beforeFindRecord', filter, options)
   const result = options.record ?? (await this.driver._findRecord(this, filter, options)) ?? {}
   if (!noResultSanitizer) {
     for (const idx in result.data) {
@@ -94,6 +95,7 @@ async function findRecord (...args) {
     }
   }
   if (isSet(options.refs)) await getMultiRefs.call(this, result.data, options)
+  await execDynHook.call(this, 'afterFindRecord', filter, result, options)
   await execModelHook.call(this, 'afterFindRecord', filter, result, options)
   await execHook.call(this, 'afterFindRecord', filter, result, options)
   if (!noCache) await runHook('cache:setByFilter', this, filter, result)

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, getSingleRef } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getSingleRef } from './_util.js'
 const action = 'getRecord'
 
 /**
@@ -55,6 +55,7 @@ async function getRecord (...args) {
   id = this.sanitizeId(id)
   await execHook.call(this, 'beforeGetRecord', id, options)
   await execModelHook.call(this, 'beforeGetRecord', id, options)
+  await execDynHook.call(this, 'beforeGetRecord', id, options)
   if (!noCache) {
     try {
       await runHook('cache:getById', this, id)
@@ -70,7 +71,8 @@ async function getRecord (...args) {
   if (isEmpty(result.data) && !options.throwNotFound) return dataOnly ? undefined : { data: undefined }
   if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
   if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
-  await execModelHook.call(this, 'afterGetRecord', id, result.data, options)
+  await execDynHook.call(this, 'afterGetRecord', id, result, options)
+  await execModelHook.call(this, 'afterGetRecord', id, result, options)
   await execHook.call(this, 'afterGetRecord', id, result, options)
   if (!noCache) await runHook('cache:setById', this, id, result)
   return dataOnly ? result.data : result

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, getSingleRef, handleReq } from './_util.js'
 const action = 'removeRecord'
 
 /**
@@ -42,6 +42,7 @@ async function removeRecord (...args) {
   id = this.sanitizeId(id)
   await execHook.call(this, 'beforeRemoveRecord', id, options)
   await execModelHook.call(this, 'beforeRemoveRecord', id, options)
+  await execDynHook.call(this, 'beforeRemoveRecord', id, options)
   const result = options.record ?? (await this.driver._removeRecord(this, id, options)) ?? {}
   if (noResult) {
     await runHook('cache:clear', this, 'remove', id)
@@ -50,6 +51,7 @@ async function removeRecord (...args) {
   if (!noResultSanitizer) result.oldData = await this.sanitizeRecord(result.oldData, options)
   if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
   await handleReq.call(this, result.oldData.id, 'removed', options)
+  await execDynHook.call(this, 'afterRemoveRecord', id, result, options)
   await execModelHook.call(this, 'afterRemoveRecord', id, result, options)
   await execHook.call(this, 'afterRemoveRecord', id, result, options)
   await runHook('cache:clear', this, 'remove', id, result)

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execValidation, execModelHook, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execValidation, execModelHook, execDynHook, getSingleRef, handleReq } from './_util.js'
 import { onlyTypes } from './create-record.js'
 const action = 'updateRecord'
 
@@ -60,6 +60,7 @@ async function updateRecord (...args) {
   delete input.id
   await execHook.call(this, 'beforeUpdateRecord', id, input, options)
   await execModelHook.call(this, 'beforeUpdateRecord', id, input, options)
+  await execDynHook.call(this, 'beforeUpdateRecord', id, input, options)
   if (!noValidation) await execValidation.call(this, input, options)
   const result = options.record ?? (await this.driver._updateRecord(this, id, input, options)) ?? {}
   if (noResult) {
@@ -72,6 +73,7 @@ async function updateRecord (...args) {
   }
   if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
   await handleReq.call(this, result.data.id, 'updated', options)
+  await execDynHook.call(this, 'afterUpdateRecord', id, input, result, options)
   await execModelHook.call(this, 'afterUpdateRecord', id, input, result, options)
   await execHook.call(this, 'afterUpdateRecord', id, input, result, options)
   await runHook('cache:clear', this, 'update', id, body, result)

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

@@ -1,4 +1,4 @@
-import { getFilterAndOptions, execHook, execModelHook, execValidation, getSingleRef, handleReq } from './_util.js'
+import { getFilterAndOptions, execHook, execModelHook, execDynHook, execValidation, getSingleRef, handleReq } from './_util.js'
 const action = 'upsertRecord'
 
 async function native (body = {}, opts = {}) {
@@ -13,6 +13,7 @@ async function native (body = {}, opts = {}) {
   if (!noValidation) input = await execValidation.call(this, input, options)
   await execHook.call(this, 'beforeUpsertRecord', input, options)
   await execModelHook.call(this, 'beforeUpsertRecord', input, options)
+  await execDynHook.call(this, 'beforeUpsertRecord', input, options)
   const result = options.record ?? (await this.driver._upsertRecord(this, input, options)) ?? {}
   if (noResult) {
     await runHook('cache:clear', this, 'upsert', body)
@@ -21,6 +22,7 @@ async function native (body = {}, opts = {}) {
   if (!noResultSanitizer) result.data = await this.sanitizeRecord(result.data, options)
   if (isSet(options.refs)) await getSingleRef.call(this, result.data, options)
   await handleReq.call(this, result.data.id, 'upserted', options)
+  await execDynHook.call(this, 'afterUpsertRecord', input, result, options)
   await execModelHook.call(this, 'afterUpsertRecord', input, result, options)
   await execHook.call(this, 'afterUpsertRecord', input, result, options)
   await runHook('cache:clear', this, 'upsert', body, result)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dobo",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "description": "DBMS for Bajo Framework",
   "main": "index.js",
   "scripts": {

package/wiki/CHANGES.md

@@ -1,5 +1,15 @@
 # Changes
 
+## 2026-01-24
+
+- [2.3.0] Add ```dynHooks``` to model's options
+- [2.3.0] Add ```dobo:unique``` feature
+- [2.3.0] Add ```noWait``` handler for model's hook
+
+## 2026-01-21
+
+- [2.2.5] Add ```proto``` to ```connection.options```
+
 ## 2026-01-19
 
 - [2.2.4] Bug fix on route ```dobo:/attachment/...```

package/extend/dobo/feature/int-id.js

@@ -1,13 +0,0 @@
-async function intId (opts = {}) {
-  return {
-    properties: [{
-      name: 'id',
-      type: 'integer',
-      required: true,
-      index: 'primary',
-      unsigned: true
-    }]
-  }
-}
-
-export default intId