- simple refactoring BusinessLogic Service

- simple refactoring Cache Service

Author: Valodya

src/bl/dispatch-event.js

@@ -3,25 +3,28 @@ import Request from '../request'
 import Async from '../request/async'
 import Urls from '../urls'
 
-export function dispatchEvent(eventName, eventArgs) {
+export function dispatchEvent(eventName, eventArgs, asyncHandler) {
   if (!eventName || !Utils.isString(eventName)) {
     throw new Error('Event Name must be provided and must be not an empty STRING!')
   }
 
-  eventArgs = (Utils.isObject(eventArgs) && !(eventArgs instanceof Async)) ? eventArgs : {}
-
-  let responder = Utils.extractResponder(arguments)
+  if (eventArgs instanceof Async) {
+    asyncHandler = eventArgs
+    eventArgs = undefined
+  }
 
-  if (responder) {
-    responder = Utils.wrapAsync(responder)
+  if (!Utils.isObject(eventArgs)) {
+    eventArgs = {}
   }
 
-  eventArgs = eventArgs instanceof Async ? {} : eventArgs
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler)
+  }
 
   return Request.post({
     url         : Urls.blEvent(eventName),
     data        : eventArgs,
-    isAsync     : !!responder,
-    asyncHandler: responder
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
   })
 }

src/bl/invoke-service-method.js

@@ -1,14 +1,17 @@
-import Utils from '../utils'
 import Urls from '../urls'
 import Request from '../request'
+import Async from '../request/async'
 
-export function invokeServiceMethod(serviceName, method, parameters /**, async */) {
-  const responder = Utils.extractResponder(arguments)
+export function invokeServiceMethod(serviceName, method, parameters, asyncHandler) {
+  if (parameters instanceof Async) {
+    asyncHandler = parameters
+    parameters = undefined
+  }
 
   return Request.post({
     url         : Urls.blServiceMethod(serviceName, method),
     data        : parameters,
-    isAsync     : !!responder,
-    asyncHandler: responder
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
   })
 }

src/cache/cache-methods.js

@@ -1,5 +1,19 @@
-import { cacheMethod } from './cache-methods'
+import Utils from '../utils'
+import Urls from '../urls'
+import Request from '../request'
 
 export function contains(key, asyncHandler) {
-  return cacheMethod('GET', key, true, asyncHandler)
+  if (!key || !Utils.isString(key)) {
+    throw new Error('Cache Key must be non empty String')
+  }
+
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler)
+  }
+
+  return Request.get({
+    url         : Urls.cacheItemCheck(key),
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
+  })
 }

src/cache/contains.js

@@ -2,25 +2,26 @@ import Utils from '../utils'
 import Urls from '../urls'
 import Request from '../request'
 
-export function expireAt(key, timestamp /**, async */) {
-  if (Utils.isString(key) && (Utils.isNumber(timestamp) || Utils.isDate(timestamp)) && timestamp) {
-    timestamp = (Utils.isDate(timestamp)) ? timestamp.getTime() : timestamp
-    let responder = Utils.extractResponder(arguments), isAsync = false
-    if (responder) {
-      isAsync = true
-      responder = Utils.wrapAsync(responder)
-    }
+export function expireAt(key, timestamp, asyncHandler) {
+  if (!key || !Utils.isString(key)) {
+    throw new Error('Cache Key must be non empty String')
+  }
+
+  if (!timestamp) {
+    throw new Error('Cache Expiration must be timestamp or instance of Date')
+  }
 
-    return Request.put({
-      url         : Urls.cacheItemExpireAt(key) + '?timestamp=' + timestamp,
-      data        : {},
-      isAsync     : isAsync,
-      asyncHandler: responder
-    })
-  } else {
-    throw new Error(
-      'You can use only String as key while expire in Cache. ' +
-      'Second attribute must be declared and must be a Number or Date type'
-    )
+  timestamp = Utils.isDate(timestamp) ? timestamp.getTime() : timestamp
+
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler)
   }
+
+  return Request.put({
+    url         : Urls.cacheItemExpireAt(key) + '?timestamp=' + timestamp,
+    data        : {},
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
+  })
+
 }

src/cache/expire-at.js

@@ -2,25 +2,24 @@ import Utils from '../utils'
 import Urls from '../urls'
 import Request from '../request'
 
-export function expireIn(key, seconds /**, async */) {
-  if (Utils.isString(key) && (Utils.isNumber(seconds) || Utils.isDate(seconds)) && seconds) {
-    seconds = (Utils.isDate(seconds)) ? seconds.getTime() : seconds
+export function expireIn(key, seconds, asyncHandler) {
+  if (!key || !Utils.isString(key)) {
+    throw new Error('Cache Key must be non empty String')
+  }
 
-    let responder = Utils.extractResponder(arguments)
-    const isAsync = !!responder
+  if (!seconds) {
+    throw new Error('Cache Expiration must be number of seconds')
+  }
 
-    if (responder) {
-      responder = Utils.wrapAsync(responder)
-    }
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler)
+  }
 
-    return Request.put({
-      url         : Urls.cacheItemExpireIn(key) + '?timeout=' + seconds,
-      data        : {},
-      isAsync     : isAsync,
-      asyncHandler: responder
-    })
+  return Request.put({
+    url         : Urls.cacheItemExpireIn(key) + '?timeout=' + seconds,
+    data        : {},
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
+  })
 
-  } else {
-    throw new Error('The "key" argument must be String. The "seconds" argument can be either Number or Date')
-  }
 }

src/cache/expire-in.js

@@ -3,37 +3,38 @@ import Urls from '../urls'
 import Request from '../request'
 import { Parsers } from './parsers'
 
-export function get(key /**, async */) {
-  if (!Utils.isString(key)) {
-    throw new Error('The "key" argument must be String')
-  }
-
-  function parseResult(result) {
-    const className = result && result.___class
+function parseResult(result) {
+  const className = result && result.___class
 
-    if (className) {
-      const clazz = Parsers.get(className) // || root[className]
+  if (className) {
+    const Class = Parsers.get(className)
 
-      if (clazz) {
-        result = new clazz(result)
-      }
+    if (Class) {
+      result = new Class(result)
     }
-
-    return result
   }
 
-  let responder = Utils.extractResponder(arguments), isAsync = false
+  return result
+}
+
+export function get(key, asyncHandler) {
+  if (!key || !Utils.isString(key)) {
+    throw new Error('Cache Key must be non empty String')
+  }
 
-  if (responder) {
-    isAsync = true
-    responder = Utils.wrapAsync(responder, parseResult, this)
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler, parseResult)
   }
 
   const result = Request.get({
     url         : Urls.cacheItem(key),
-    isAsync     : isAsync,
-    asyncHandler: responder
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
   })
 
-  return isAsync ? result : parseResult(result)
+  if (asyncHandler) {
+    return result
+  }
+
+  return parseResult(result)
 }

src/cache/get.js

@@ -4,38 +4,32 @@ import Async from '../request/async'
 import Request from '../request'
 
 export function put(key, value, timeToLive, asyncHandler) {
-  if (!Utils.isString(key)) {
-    throw new Error('You can use only String as key to put into Cache')
+  if (!key || !Utils.isString(key)) {
+    throw new Error('Cache Key must be non empty String')
   }
 
-  if (!(timeToLive instanceof Async)) {
-    if (typeof timeToLive === 'object' && !arguments[3]) {
-      asyncHandler = timeToLive
-      timeToLive = null
-    } else if (typeof timeToLive !== ('number' || 'string') && timeToLive != null) {
-      throw new Error('You can use only String as timeToLive attribute to put into Cache')
-    }
-  } else {
+  if (timeToLive instanceof Async) {
     asyncHandler = timeToLive
-    timeToLive = null
+    timeToLive = undefined
+  }
+
+  if (timeToLive && !Utils.isNumber(key)) {
+    throw new Error('Cache timeToLive must be Number')
   }
 
   if (Utils.isObject(value) && value.constructor !== Object) {
     value.___class = value.___class || Utils.getClassName(value)
   }
 
-  let responder = Utils.extractResponder([asyncHandler])
-  const isAsync = !!responder
-
-  if (responder) {
-    responder = Utils.wrapAsync(responder)
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler)
   }
 
   return Request.put({
     url         : Urls.cacheItem(key) + ((timeToLive) ? '?timeout=' + timeToLive : ''),
     headers     : { 'Content-Type': 'application/json' },
     data        : JSON.stringify(value),
-    isAsync     : isAsync,
-    asyncHandler: responder
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
   })
 }

src/cache/put.js

@@ -1,5 +1,19 @@
-import { cacheMethod } from './cache-methods'
+import Utils from '../utils'
+import Urls from '../urls'
+import Request from '../request'
 
 export function remove(key, asyncHandler) {
-  return cacheMethod('DELETE', key, false, asyncHandler)
+  if (!key || !Utils.isString(key)) {
+    throw new Error('Cache Key must be non empty String')
+  }
+
+  if (asyncHandler) {
+    asyncHandler = Utils.wrapAsync(asyncHandler)
+  }
+
+  return Request.delete({
+    url         : Urls.cacheItem(key),
+    isAsync     : !!asyncHandler,
+    asyncHandler: asyncHandler
+  })
 }