dobo 1.2.2 → 1.2.4

package/index.js

@@ -327,10 +327,11 @@ async function factory (pkgName) {
 
     getInfo = (name) => {
       const { breakNsPath } = this.app.bajo
-      const { find, map } = this.lib._
+      const { find, map, isEmpty } = this.lib._
       const schema = this.getSchema(name)
       const conn = this.getConnection(schema.connection)
-      const { ns, path: type } = breakNsPath(conn.type)
+      let { ns, path: type } = breakNsPath(conn.type)
+      if (isEmpty(type)) type = conn.type
       const driver = find(this.drivers, { type, ns, driver: conn.driver })
       const instance = find(this.app[driver.ns].instances, { name: schema.connection })
       const opts = conn.type === 'mssql' ? { includeTriggerModifications: true } : undefined

package/lib/collect-connections.js

@@ -5,9 +5,10 @@ async function defSanitizer (item) {
 async function collectConnections ({ item, index, options }) {
   const conn = item
   const { importModule, breakNsPath } = this.app.bajo
-  const { has, find } = this.lib._
+  const { has, find, isEmpty } = this.lib._
   if (!has(conn, 'type')) this.fatal('mustValidDbType')
-  const { ns, path: type } = breakNsPath(conn.type)
+  let { ns, path: type } = breakNsPath(conn.type)
+  if (isEmpty(type)) type = conn.type
   const driver = find(this.drivers, { ns, type })
   if (!driver) this.fatal('unsupportedDbType%s', conn.type)
   let file = `${ns}:/${this.name}/lib/${type}/conn-sanitizer.js`

package/lib/collect-drivers.js

@@ -23,7 +23,7 @@ async function collectDrivers () {
       const [type, provider] = t.split('@')
       const exists = find(me.drivers, { type, ns })
       if (exists) this.fatal('dbTypeAlreadySupportedByDriver%s%s', type, info.driver)
-      const driver = pick(find(me.app[ns].drivers, { name: type }) ?? {}, ['dialect', 'idField', 'lowerCaseColl', 'returning'])
+      const driver = pick(find(me.app[ns].drivers, { name: type }) ?? {}, ['dialect', 'idField', 'lowerCaseModel', 'returning'])
       const ext = {
         type,
         ns,

package/lib/sanitize-schema.js

@@ -23,7 +23,7 @@ async function sanitizeFeature (item) {
 async function sanitizeIndexes (item) {
   const { generateId } = this.app.bajo
   for (const idx of item.indexes) {
-    if (!idx.name) idx.name = `${(item.collName ?? item.name).toUpperCase()}_${generateId()}`
+    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)
   }
 }
@@ -53,9 +53,10 @@ async function sanitizeSchema (items) {
       if (!conn) fatal.call(this, 'Unknown connection \'%s@%s\'', item.name, item.connection)
       item.fullText = item.fullText ?? { fields: [] }
       item.indexes = item.indexes ?? []
-      const { ns, path: type } = breakNsPath(conn.type)
+      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.lowerCaseColl) item.name = item.name.toLowerCase()
+      if (driver.lowerCaseModel) item.name = item.name.toLowerCase()
       let file = `${ns}:/${this.name}/lib/${type}/prop-sanitizer.js`
       let propSanitizer = await importModule(file)
       if (!propSanitizer) propSanitizer = genericPropSanitizer

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "dobo",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Database ORM/ODM for Bajo Framework",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "type": "module",
+  "bajo": {
+    "type": "plugin"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ardhi/dobo.git"

package/plugin-method/model/clear.js

@@ -6,12 +6,12 @@ async function clear (name, options = {}) {
 
   await this.modelExists(name, true)
   const { noHook } = options
-  const { handler, schema } = await resolveMethod.call(this, name, 'model-clear', options)
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-clear', options)
   if (!noHook) {
     await runHook(`${this.name}:beforeModelClear`, schema, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeModelClear`, options)
   }
-  const resp = await handler.call(this, { schema, options })
+  const resp = await handler.call(this.app[driver.ns], { schema, options })
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterModelClear`, options, resp)
     await runHook(`${this.name}:afterModelClear`, schema, options, resp)

package/plugin-method/model/create.js

@@ -4,12 +4,12 @@ async function create (name, options = {}) {
   const { runHook } = this.app.bajo
   const { camelCase } = this.lib._
 
-  const { handler, schema } = await resolveMethod.call(this, name, 'model-create', options)
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-create', options)
   if (!options.noHook) {
     await runHook(`${this.name}:beforeModelCreate`, schema, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeModelCreate`, options)
   }
-  await handler.call(this, { schema, options })
+  await handler.call(this.app[driver.ns], { schema, options })
   if (!options.noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterModelCreate`, options)
     await runHook(`${this.name}:afterModelCreate`, schema, options)

package/plugin-method/model/drop.js

@@ -3,13 +3,13 @@ import resolveMethod from '../../lib/resolve-method.js'
 async function drop (name, options = {}) {
   const { runHook } = this.app.bajo
   const { camelCase } = this.lib._
-  const { handler, schema } = await resolveMethod.call(this, name, 'model-drop', options)
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-drop', options)
 
   if (!options.noHook) {
     await runHook(`${this.name}:beforeModelDrop`, schema, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeModelDrop`, options)
   }
-  await handler.call(this, { schema, options })
+  await handler.call(this.app[driver.ns], { schema, options })
   if (!options.noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterModelDrop`, options)
     await runHook(`${this.name}:afterModelDrop`, schema, options)

package/plugin-method/model/exists.js

@@ -6,12 +6,12 @@ async function exists (name, thrown, options = {}) {
   if (cache[name]) return cache[name]
   const { runHook } = this.app.bajo
   const { camelCase } = this.lib._
-  const { handler, schema } = await resolveMethod.call(this, name, 'model-exists', options)
+  const { handler, schema, driver } = await resolveMethod.call(this, name, 'model-exists', options)
   if (!options.noHook) {
     await runHook(`${this.name}:beforeModelExists`, schema, options)
     await runHook(`${this.name}.${camelCase(name)}:beforeModelExists`, options)
   }
-  const exist = await handler.call(this, { schema, options })
+  const exist = await handler.call(this.app[driver.ns], { schema, options })
   if (!options.noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterModelExists`, exist, options)
     await runHook(`${this.name}:afterModelExists`, schema, exist, options)

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

@@ -6,7 +6,7 @@ async function findOne (name, filter = {}, opts = {}) {
   const { isSet } = this.lib.aneka
   const { runHook } = this.app.bajo
   const { get, set } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.lib._
+  const { cloneDeep, camelCase, omit, pick } = this.lib._
   delete opts.record
   const options = cloneDeep(omit(opts, ['req', 'reply']))
   options.req = opts.req
@@ -37,12 +37,13 @@ async function findOne (name, filter = {}, opts = {}) {
   }
   filter.limit = 1
   filter.page = 1
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
+  let record = options.record ?? (await handler.call(this.app[driver.ns], { schema, filter, options }))
   delete options.record
   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 })
+  record = pick(record, ['data'])
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordFindOne`, filter, options, record)
     await runHook(`${this.name}:afterRecordFindOne`, name, filter, options, record)