feat: ✨ Workflow and Concurrency in request

- Workflow support added
- Request concurrency support added

Author: uttamukkoji

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [v1.2.0](https://github.com/contentstack/contentstack-management-javascript/tree/v1.2.0) (.....)
+ - Bug Fix
+   - Release Items issue for API key resolved
+ - Enhanchment 
+   - Request concurrency added in SDK
+ - New Feature
+   - Workflow module support added
 ## [v1.1.2](https://github.com/contentstack/contentstack-management-javascript/tree/v1.1.2) (2021-01-07)
  - Bug Fix
    - Retry count on multiple request failuer

lib/contentstack.js

@@ -113,7 +113,7 @@ export function client (params = {}) {
     defaultHostName: 'api.contentstack.io'
   }
 
-  const sdkAgent = `${packages.name}-javascript/${packages.version}`
+  const sdkAgent = `contentstack-management-javascript/${packages.version}`
   const userAgentHeader = getUserAgent(sdkAgent,
     params.application,
     params.integration,

lib/contentstackClient.js

@@ -164,6 +164,7 @@ export default function contentstackClient ({ http }) {
     logout: logout,
     getUser: getUser,
     stack: stack,
-    organization: organization
+    organization: organization,
+    axiosInstance: http
   }
 }

lib/core/concurrency-queue.js

@@ -0,0 +1,215 @@
+import { set } from "lodash";
+import Axios from 'axios'
+const defaultConfig = {
+    maxRequests: 5,
+    retryLimit: 5,
+    retryDelay: 300,
+}
+
+export function ConcurrencyQueue ({axios, config}) {
+    if (!axios) {
+        throw Error('Axios instance is not present');
+    }
+
+    if (config) {
+        if (config.maxRequests && config.maxRequests <= 0) {
+            throw Error('Concurrency Manager Error: minimun concurrent requests is 1');
+        } else if (config.retryLimit && config.retryLimit <= 0) {
+            throw Error('Retry Policy Error: minimun retry limit is 1');
+        } else if (config.retryDelay && config.retryDelay < 300) {
+            throw Error('Retry Policy Error: minimun retry delay for requests is 300');
+        }
+    }
+
+    this.config = Object.assign({}, defaultConfig, config)
+    this.queue = []
+    this.running = []
+    this.paused = false
+    
+    // Initial shift will check running request,
+    // and adds request to running queue if max requests are not running
+    this.initialShift = () => {
+        if (this.running.length < this.config.maxRequests && !this.paused) {
+            shift()
+        }
+    }
+
+    // INTERNAL: Shift the queued item to running queue
+    let shift = () => {
+        if (this.queue.length && !this.paused) {
+            const queueItem = this.queue.shift()
+            queueItem.resolve(queueItem.request)
+            this.running.push(queueItem)
+        }
+    }
+
+    // Append the request at start of queue
+    this.unshift = requestPromise => {
+        this.queue.unshift(requestPromise)
+    }
+
+    this.push = requestPromise => {
+        this.queue.push(requestPromise)
+        this.initialShift()
+    }
+
+    this.clear = () => {
+        const requests = this.queue.splice(0, this.queue.length)
+        requests.forEach((element) => {
+            element.request.source.cancel()
+        })
+    }
+
+    // Detach the interceptors 
+    this.detach = () => {
+        axios.interceptors.request.eject(this.interceptors.request);
+        axios.interceptors.response.eject(this.interceptors.response);
+        this.interceptors = {
+            request: null,
+            response: null
+        }
+    }
+
+    // Request interseptor to queue the request
+    let requestHandler = request => {
+        request.retryCount = request.retryCount || 0
+        if (request.headers.authorization && request.headers.authorization !== undefined) {
+            delete request.headers.authtoken
+        }
+
+        if (request.cancelToken === undefined) {
+            const source = Axios.CancelToken.source()
+            request.cancelToken = source.token
+            request.source = source
+        }
+
+        if (this.paused && request.retryCount > 0) {
+            return new Promise(resolve => {
+                this.unshift({request, resolve})
+            })
+        }else if (request.retryCount > 0) {
+            return request
+        }
+
+        return new Promise(resolve => {
+            this.push({request, resolve})
+        })
+    }
+
+    let delay = (time) => {
+        if (!this.paused) {
+            this.paused = true
+            if (this.running.length > 0) {
+                setTimeout(() => {
+                    delay(time)
+                }, time) 
+            }
+            return new Promise(resolve => setTimeout(() => {
+                this.paused = false
+                for (let i=0; i<this.config.maxRequests; i++) {
+                    this.initialShift()
+                }
+            }, time));
+        }
+    }
+
+    // Response interceptor used for 
+    let responseHandler = (response) => {
+        this.running.shift()
+        shift()
+        return response
+    }
+
+    let responseErrorHandler = error => {
+        let networkError = error.config.retryCount
+        if (!this.config.retryOnError || networkError > this.config.retryLimit) {
+            return Promise.reject(responseHandler(error))
+        }
+
+        // TODO: Error handling
+        let wait = this.config.retryDelay
+        let retryErrorType = null
+        let response = error.response
+        if (!response) {
+            if (error.code === 'ECONNABORTED') {
+                error.response = {
+                    ...error.response,
+                    status: 408,
+                    statusText: `timeout of ${this.config.timeout}ms exceeded`
+                }
+            }else {
+                return Promise.reject(responseHandler(error))
+            }
+        }else if (response.status === 429) {
+            retryErrorType = `Error with status: ${response.status}`
+            networkError++
+
+            if (networkError > this.config.retryLimit) {
+                return Promise.reject(responseHandler(error))
+            }
+            this.running.shift()
+            // Cooldown the running requests 
+            delay(1000)
+            error.config.retryCount = networkError
+
+            return axios(updateRequestConfig(error, retryErrorType, wait))
+        }else if (this.config.retryCondition && this.config.retryCondition(error)) {
+            retryErrorType = `Error with status: ${response.status}`
+            networkError++
+            if (networkError > this.config.retryLimit) {
+              return Promise.reject(responseHandler(error))
+            }
+            if (this.config.retryDelayOptions) {
+              if (this.config.retryDelayOptions.customBackoff) {
+                wait = this.config.retryDelayOptions.customBackoff(networkError, error)
+                if (wait && wait <= 0) {
+                  return Promise.reject(responseHandler(error))
+                }
+              } else if (this.config.retryDelayOptions.base) {
+                wait = this.config.retryDelayOptions.base * networkError
+              }
+            } else {
+              wait = this.config.retryDelay
+            }
+            error.config.retryCount = networkError
+            return new Promise(function (resolve) {
+                return setTimeout(function () {
+                  return resolve(axios(updateRequestConfig(error, retryErrorType, wait)))
+                }, wait)
+              })
+          }
+
+        return Promise.reject(responseHandler(error))
+    }
+
+    this.interceptors = {
+        request: null,
+        response: null
+    }
+
+    let updateRequestConfig = (error, retryErrorType, wait) => {
+        const requestConfig = error.config
+        this.config.logHandler('warning', `${retryErrorType} error occurred. Waiting for ${wait} ms before retrying...`)
+        if (axios !== undefined && axios.defaults !== undefined) {
+            if (axios.defaults.agent === requestConfig.agent) {
+                delete requestConfig.agent
+            }
+            if (axios.defaults.httpAgent === requestConfig.httpAgent) {
+                delete requestConfig.httpAgent
+            }
+            if (axios.defaults.httpsAgent === requestConfig.httpsAgent) {
+                delete requestConfig.httpsAgent
+            }
+        }
+    
+        requestConfig.transformRequest = [function (data) {
+            return data
+        }]
+        return requestConfig
+    }
+
+    // Adds interseptors in axios to queue request
+    this.interceptors.request = axios.interceptors.request.use(requestHandler)
+    this.interceptors.response = axios.interceptors.response.use(responseHandler, responseErrorHandler)
+
+}

lib/core/contentstack-retry.js

@@ -1,8 +1,8 @@
 import clonedeep from 'lodash/cloneDeep'
 import Qs from 'qs'
 import axios from 'axios'
-import contentstackRetry from './contentstack-retry'
 import { isHost } from './Util'
+import { ConcurrencyQueue } from './concurrency-queue'
 
 export default function contentstackHttpClient (options) {
   const defaultConfig = {
@@ -77,6 +77,6 @@ export default function contentstackHttpClient (options) {
   }
   const instance = axios.create(axiosOptions)
   instance.httpClientParams = options
-  contentstackRetry(instance, axiosOptions, config.retyLimit, config.retryDelay)
+  instance.concurrencyQueue = new ConcurrencyQueue({axios: instance, config})
   return instance
 }

lib/core/contentstackHTTPClient.js

@@ -128,7 +128,20 @@ export const query = ({ http, wrapperCollection }) => {
 export const update = (http, type) => {
   return async function (param = {}) {
     const updateData = {}
-    updateData[type] = cloneDeep(this)
+    const json = cloneDeep(this)
+    delete json.stackHeaders
+    delete json.urlPath
+    delete json.uid
+    delete json.org_uid
+    delete json.api_key
+    delete json.created_at
+    delete json.created_by
+    delete json.deleted_at
+    delete json.updated_at
+    delete json.updated_by
+    delete json.updated_at
+
+    updateData[type] = json
     try {
       const response = await http.put(this.urlPath, updateData, { headers: {
         ...cloneDeep(this.stackHeaders)

lib/entity.js

@@ -109,7 +109,7 @@ export function Release (http, data = {}) {
      * .then((items) => console.log(items))
      */
     this.item = () => {
-      return new ReleaseItem(http, { releaseUid: this.uid })
+      return new ReleaseItem(http, { releaseUid: this.uid , stackHeaders: this.stackHeaders })
     }
     /**
      * @description The Deploy a Release request deploys a specific Release to specific environment(s) and locale(s).