- some minor refactoring Data Service

Author: Valodya

src/data/persistence.js

@@ -12,11 +12,11 @@ export function bulkCreate(objectsArray, asyncHandler) {
     throw new Error(MSG_ERROR)
   }
 
-  for (let i = 0; i < objectsArray.length; i++) {
-    if (!Utils.isObject(objectsArray[i])) {
+  objectsArray.forEach(obj => {
+    if (!Utils.isObject(obj)) {
       throw new Error(MSG_ERROR)
     }
-  }
+  })
 
   return Request.post({
     url         : Urls.dataBulkTable(this.className),
@@ -26,17 +26,18 @@ export function bulkCreate(objectsArray, asyncHandler) {
   })
 }
 
-export function bulkUpdate(templateObject, whereClause, asyncHandler) {
+export function bulkUpdate(templateObject, where, asyncHandler) {
   if (!templateObject || !Utils.isObject(templateObject)) {
     throw new Error('Invalid templateObject argument. The first argument must contain object')
   }
 
-  if (!whereClause || !Utils.isString(whereClause)) {
+  if (!where || !Utils.isString(where)) {
     throw new Error('Invalid whereClause argument. The first argument must contain "whereClause" string.')
   }
 
   return Request.put({
-    url         : Urls.dataBulkTable(this.className) + '?' + Utils.toQueryParams({ where: whereClause }),
+    url         : Urls.dataBulkTable(this.className),
+    query       : { where },
     data        : templateObject,
     isAsync     : !!asyncHandler,
     asyncHandler: asyncHandler
@@ -49,28 +50,31 @@ export function bulkDelete(objectsArray, asyncHandler) {
     'The first argument must contain array of objects or array of id or "whereClause" string'
   )
 
-  if (!objectsArray || (!Utils.isArray(objectsArray) && !Utils.isString(objectsArray))) {
+  if (!Utils.isArray(objectsArray) && !Utils.isString(objectsArray)) {
     throw new Error(MSG_ERROR)
   }
 
-  for (let i = 0; i < objectsArray.length; i++) {
-    if (!Utils.isObject(objectsArray[i]) && !Utils.isString(objectsArray[i])) {
-      throw new Error(MSG_ERROR)
-    }
-  }
-
-  let whereClause
+  let where
 
   if (Utils.isString(objectsArray)) {
-    whereClause = objectsArray
+    where = objectsArray
+
   } else if (Utils.isArray(objectsArray)) {
-    const objects = objectsArray.map(obj => Utils.isString(obj) ? obj : obj.objectId)
 
-    whereClause = 'objectId in (\'' + objects.join('\', \'') + '\')'
+    const objects = objectsArray.map(obj => {
+      if (!Utils.isObject(obj) && !Utils.isString(obj)) {
+        throw new Error(MSG_ERROR)
+      }
+
+      return `'${Utils.isString(obj) ? obj : obj.objectId}'`
+    })
+
+    where = `objectId in (${objects.join(',')})`
   }
 
   return Request.delete({
-    url         : Urls.dataBulkTable(this.className) + '?' + Utils.toQueryParams({ where: whereClause }),
+    url         : Urls.dataBulkTable(this.className),
+    query       : { where },
     isAsync     : !!asyncHandler,
     asyncHandler: asyncHandler
   })

src/data/store/bulk.js

@@ -7,21 +7,16 @@ import DataQueryBuilder from '../query-builder'
 export function getObjectCount(condition, asyncHandler) {
   if (condition instanceof Async) {
     asyncHandler = condition
-    condition = null
+    condition = undefined
   }
 
   if (condition instanceof DataQueryBuilder) {
     condition = condition.build().condition
   }
 
-  let url = Urls.dataTableCount(this.className)
-
-  if (condition) {
-    url += '?where=' + encodeURIComponent(condition)
-  }
-
   return Request.get({
-    url         : url,
+    url         : Urls.dataTableCount(this.className),
+    query       : { where: condition },
     isAsync     : !!asyncHandler,
     asyncHandler: asyncHandler
   })

src/data/store/count.js

@@ -1,5 +1,9 @@
 import Utils from '../../utils'
 
+
+//TODO: refactor me
+//TODO: does make sense to move this logic into QueryBuilder?
+
 export function extractQueryOptions(options) {
   const params = []
 

src/data/store/extract-query-options.js

@@ -8,43 +8,32 @@ import QueryBuilder from '../query-builder'
 import { parseFindResponse } from './parse'
 import { extractQueryOptions } from './extract-query-options'
 
+
+//TODO: refactor me
+
 export function findUtil(className, Model, dataQuery, asyncHandler) {
   dataQuery = dataQuery || {}
 
-  let props
-  let whereClause
-  let options
   const query = []
-  let url = Urls.dataTable(className)
-
-  if (dataQuery.properties && dataQuery.properties.length) {
-    props = 'props=' + Utils.encodeArrayToUriComponent(dataQuery.properties)
-  }
-
-  if (dataQuery.condition) {
-    whereClause = 'where=' + encodeURIComponent(dataQuery.condition)
-  }
-
-  if (dataQuery.options) {
-    options = extractQueryOptions(dataQuery.options)
-  }
 
   if (asyncHandler) {
     asyncHandler = Utils.wrapAsync(asyncHandler, resp => parseFindResponse(resp, Model))
   }
 
-  if (options) {
-    query.push(options)
+  if (dataQuery.options) {
+    query.push(extractQueryOptions(dataQuery.options))
   }
 
-  if (whereClause) {
-    query.push(whereClause)
+  if (dataQuery.condition) {
+    query.push('where=' + encodeURIComponent(dataQuery.condition))
   }
 
-  if (props) {
-    query.push(props)
+  if (dataQuery.properties && dataQuery.properties.length) {
+    query.push('props=' + Utils.encodeArrayToUriComponent(dataQuery.properties))
   }
 
+  let url = Urls.dataTable(className)
+
   if (dataQuery.url) {
     url += '/' + dataQuery.url
   }
@@ -129,8 +118,6 @@ export function findById() {
     }
 
     return isAsync ? result : parseFindResponse(result, this.model)
-  } else {
-    throw new Error('Invalid value for the "value" argument. The argument must contain only string or object values')
   }
 }
 

src/data/store/find.js

@@ -1,5 +1,7 @@
 import Utils from '../../utils'
 
+//TODO: refactor me
+
 function formCircDeps(obj) {
   const result = new obj.constructor()
   const circDepsIDs = {}

src/data/store/parse.js

@@ -7,6 +7,8 @@ import LoadRelationsQueryBuilder from '../load-relations-query-builder'
 import { extractQueryOptions } from './extract-query-options'
 import { parseFindResponse } from './parse'
 
+//TODO: refactor me
+
 function collectRelationObject(parent, columnName, children) {
   const relation = {
     columnName
@@ -73,12 +75,12 @@ function buildRelationUrl(className, relation) {
   return url
 }
 
-export function loadRelations(parentObjectId, queryBuilder/**, async */) {
+export function loadRelations(parentObjectId, queryBuilder, asyncHandler) {
   if (!parentObjectId || !Utils.isString(parentObjectId)) {
     throw new Error('The parentObjectId is required argument and must be a nonempty string')
   }
 
-  if (!queryBuilder || !(queryBuilder instanceof LoadRelationsQueryBuilder)) {
+  if (!(queryBuilder instanceof LoadRelationsQueryBuilder)) {
     throw new Error(
       'Invalid queryBuilder object.' +
       'The queryBuilder is required and must be instance of the Backendless.LoadRelationsQueryBuilder'
@@ -93,27 +95,25 @@ export function loadRelations(parentObjectId, queryBuilder/**, async */) {
     throw new Error('The options relationName is required and must contain string value')
   }
 
-  let whereClause
   let options
   const query = []
 
-  if (dataQuery.condition) {
-    whereClause = 'where=' + encodeURIComponent(dataQuery.condition)
-  }
-
   if (dataQuery.options) {
     options = extractQueryOptions(dataQuery.options)
   }
 
-  options && query.push(options)
-  whereClause && query.push(whereClause)
+  if (options) {
+    query.push(options)
+  }
+
+  if (dataQuery.condition) {
+    query.push('where=' + encodeURIComponent(dataQuery.condition))
+  }
 
-  const relationModel = dataQuery.relationModel || null
-  let responder = Utils.extractResponder(arguments)
   let url = Urls.dataTable(this.className) + Utils.toUri(parentObjectId, relationName)
 
-  if (responder) {
-    responder = Utils.wrapAsync(responder, resp => parseFindResponse(resp, relationModel))
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler, resp => parseFindResponse(resp, dataQuery.relationModel))
   }
 
   if (query.length) {
@@ -122,11 +122,15 @@ export function loadRelations(parentObjectId, queryBuilder/**, async */) {
 
   const result = Request.get({
     url         : url,
-    isAsync     : !!responder,
-    asyncHandler: responder
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
   })
 
-  return !!responder ? result : parseFindResponse(result, relationModel)
+  if (asyncHandler) {
+    return result
+  }
+
+  return parseFindResponse(result, dataQuery.relationModel)
 }
 
 export function setRelation(parent, columnName, children, asyncHandler) {

src/data/store/relations.js

@@ -10,14 +10,12 @@ let lastFlushListeners
 const LoggingCollector = {
   loggers      : {},
   pool         : [],
-  messagesCount: 0,
   numOfMessages: 10,
   timeFrequency: 1,
 
   reset() {
     this.loggers = {}
     this.pool = []
-    this.messagesCount = 0
     this.numOfMessages = 10
     this.timeFrequency = 1
   },
@@ -40,16 +38,20 @@ const LoggingCollector = {
     }
 
     this.pool.push(messageObj)
-    this.messagesCount++
+
     this.checkMessagesLen()
   },
 
+  checkMessagesLen: function() {
+    if (this.pool.length >= this.numOfMessages) {
+      this.sendRequest()
+    }
+  },
+
   flush    : Utils.promisified('_flush'),
   flushSync: Utils.synchronized('_flush'),
 
-  _flush: function() {
-    const asyncHandler = Utils.extractResponder(arguments)
-
+  _flush: function(asyncHandler) {
     if (this.pool.length) {
       if (this.flushInterval) {
         clearTimeout(this.flushInterval)
@@ -80,7 +82,6 @@ const LoggingCollector = {
       })
 
       this.pool = []
-      this.messagesCount = 0
 
     } else if (asyncHandler) {
       if (lastFlushListeners) {
@@ -100,9 +101,7 @@ const LoggingCollector = {
     this.timeFrequency = timeFrequency
 
     //TODO: check when set new timeFrequency
-    if (this.messagesCount > (this.numOfMessages - 1)) {
-      this.sendRequest()
-    }
+    this.checkMessagesLen()
   }
 }