dobo 1.2.3 → 1.2.5

package/README.md

@@ -18,6 +18,22 @@ $ npm install dobo
 
 Now open your ```<bajo-data-dir>/config/.plugins``` and put ```dobo``` in it
 
+## Documentations
+
+- [Query Language](docs/query-language.md)
+
+## Database Drivers
+
+- Memory (Built-in)
+- [SQL/Knex](https://github.com/ardhi/dobo-knex)
+- [CouchDB](https://github.com/ardhi/dobo-couchdb)
+- [Elasticsearch](https://github.com/ardhi/dobo-elasticsearch)
+- [MongoDB](https://github.com/ardhi/dobo-mongodb)
+- [Redis](https://github.com/ardhi/dobo-redis)
+- [REST Proxy](https://github.com/ardhi/dobo-restproxy)
+
+More will come soon
+
 ## License
 
 [MIT](LICENSE)

package/docs/query-language.md

@@ -0,0 +1,152 @@
+# Query Language
+
+Since *dobo* use [Ghost QL](https://github.com/TryGhost/NQL) for its query language, you have the option to pick one of these syntaxes:
+
+- [NQL](https://github.com/TryGhost/NQL/tree/main/packages/nql)
+- [Mongo QL](https://www.mongodb.com/docs/manual/tutorial/query-documents/)
+
+Any NQL statements will be converted to MongoDB-like QL object first, this then passed down to the database's native QL provided by its driver.
+
+Examples from [NQL test suite](https://github.com/TryGhost/NQL/blob/main/packages/nql-lang/test/parser.test.js):
+
+## Equals
+
+count:5
+```javascript
+{ count: 5 }
+```
+
+slug:getting-started
+```javascript
+{ slug: 'getting-started' }
+```
+
+author:'Joe Bloggs'
+```javascript
+{ author: 'Joe Bloggs' }
+```
+
+## Not Equals
+count:-5
+```javascript
+{ count: { $ne: 5 } }
+```
+
+author:-'Joe Bloggs'
+```javascript
+{ author: { $ne: 'Joe Bloggs' } }
+```
+
+## Less/Greater Than or Equals
+
+count:>5
+```javascript
+{ count: { $gt: 5 } }
+```
+tag:<getting-started
+```javascript
+{ tag: { $lt: 'getting-started' } }
+```
+count:>=5
+```javascript
+{ count: { $gte: 5 } }
+```
+author:<=\'Joe Bloggs\'
+```javascript
+{ author: { $lte: 'Joe Bloggs' } }
+```
+
+## IN or NOT IN, single or multiple value
+
+count:[5]
+```javascript
+{ count: { $in: [5] } }
+```
+
+tag:-[getting-started]
+```javascript
+{ tag: { $nin: ['getting-started'] } }
+```
+
+author:-['Joe Bloggs', 'John O\\'Nolan', 'Hello World']
+```javascript
+{ author: { $nin: ['Joe Bloggs', 'John O\'Nolan', 'Hello World'] } }
+```
+
+## CONTAINS, STARTSWITH and ENDSWITH with and without NOT
+
+email:~'gmail.com'
+```javascript
+{ email: { $regex: /gmail\.com/i } }
+```
+
+email:-~'gmail.com'
+```javascript
+{ email: { $not: /gmail\.com/i } }
+```
+
+email:~^'gmail.com'
+```javascript
+{ email: { $regex: /^gmail\.com/i } }
+```
+
+email:-~^'gmail.com'
+```javascript
+{ email: { $not: /^gmail\.com/i } }
+```
+
+email:~$'gmail.com'
+```javascript
+{ email: { $regex: /gmail\.com$/i } }
+```
+
+email:-~$'gmail.com'
+```javascript
+{ email: { $not: /gmail\.com$/i } }
+```
+
+## NULL and Boolean Value
+
+image:null
+```javascript
+{ image: null }
+```
+
+featured:false
+```javascript
+{ featured: false } }
+```
+
+featured:-true
+```javascript
+{ featured: { $ne: true } }
+```
+
+## Logical Operators
+
+page:false+status:published
+```javascript
+{ $and: [{ page: false }, { status: 'published' }] }
+```
+
+page:true,featured:true
+```javascript
+{ $or: [{ page: true }, { featured: true }] }
+```
+
+## Groups/ungroups
+
+(page:false,(status:published+featured:true))
+```javascript
+{
+  $or: [
+    { page: false },
+    {
+      $and: [
+          {status: 'published'},
+          {featured: true}
+      ]
+    }
+  ]
+}
+```

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,6 +1,6 @@
 {
   "name": "dobo",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Database ORM/ODM for Bajo Framework",
   "main": "index.js",
   "scripts": {

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)