Refresh token on Unauthorized request

Author: uttamukkoji

lib/contentstack.js

@@ -119,6 +119,38 @@ import httpClient from './core/contentstackHTTPClient.js'
       console.log(`[${level}] ${data}`)
     } })
  *
+ * @prop {function=} params.refreshToken - Optional function used to refresh token.
+ * @example // OAuth example
+ * import * as contentstack from '@contentstack/management'
+ * const client = contentstack.client({
+    refreshToken: () => {
+      return new Promise((resolve, reject) => {
+        return issueToken().then((res) => {
+          resolve({
+              authorization: res.authorization
+            })
+        }).catch((error) => {
+          reject(error)
+        })
+      })
+    }
+  })
+ * @example // Auth Token example
+ * import * as contentstack from '@contentstack/management'
+ * const client = contentstack.client({
+    refreshToken: () => {
+      return new Promise((resolve, reject) => {
+        return issueToken().then((res) => {
+          resolve({
+              authtoken: res.authtoken
+            })
+        }).catch((error) => {
+          reject(error)
+        })
+      })
+    }
+  })
+ *
  * @prop {string=} params.application - Application name and version e.g myApp/version
  * @prop {string=} params.integration - Integration name and version e.g react/version
  * @returns Contentstack.Client

lib/core/concurrency-queue.js

@@ -70,16 +70,22 @@ export function ConcurrencyQueue ({ axios, config }) {
   }
 
   // Request interceptor to queue the request
-  const requestHandler = request => {
+  const requestHandler = (request) => {
     if (typeof request.data === 'function') {
       request.formdata = request.data
       request.data = transformFormData(request)
     }
     request.retryCount = request.retryCount || 0
     if (request.headers.authorization && request.headers.authorization !== undefined) {
+      if (this.config.authorization && this.config.authorization !== undefined) {
+        request.headers.authorization = this.config.authorization
+        request.authorization = this.config.authorization
+      }
       delete request.headers.authtoken
+    } else if (request.headers.authtoken && request.headers.authtoken !== undefined && this.config.authtoken && this.config.authtoken !== undefined) {
+      request.headers.authtoken = this.config.authtoken
+      request.authtoken = this.config.authtoken
     }
-
     if (request.cancelToken === undefined) {
       const source = Axios.CancelToken.source()
       request.cancelToken = source.token
@@ -102,26 +108,62 @@ export function ConcurrencyQueue ({ axios, config }) {
     })
   }
 
-  const delay = (time) => {
+  const delay = (time, isRefreshToken = false) => {
     if (!this.paused) {
       this.paused = true
       // Check for current running request.
       // Wait for running queue to complete.
       // Wait and prosed the Queued request.
       if (this.running.length > 0) {
         setTimeout(() => {
-          delay(time)
+          delay(time, isRefreshToken)
         }, time)
       }
       return new Promise(resolve => setTimeout(() => {
         this.paused = false
-        for (let i = 0; i < this.config.maxRequests; i++) {
-          this.initialShift()
+        if (isRefreshToken) {
+          return refreshToken()
+        } else {
+          for (let i = 0; i < this.config.maxRequests; i++) {
+            this.initialShift()
+          }
         }
       }, time))
     }
   }
-
+  const refreshToken = () => {
+    return config.refreshToken().then((token) => {
+      if (token.authorization) {
+        axios.defaults.headers.authorization = token.authorization
+        axios.defaults.authorization = token.authorization
+        axios.httpClientParams.authorization = token.authorization
+        axios.httpClientParams.headers.authorization = token.authorization
+        this.config.authorization = token.authorization
+      } else if (token.authtoken) {
+        axios.defaults.headers.authtoken = token.authtoken
+        axios.defaults.authtoken = token.authtoken
+        axios.httpClientParams.authtoken = token.authtoken
+        axios.httpClientParams.headers.authtoken = token.authtoken
+        this.config.authtoken = token.authtoken
+      }
+    }).catch((error) => {
+      throw error
+    }).finally(() => {
+      this.queue.forEach((queueItem) => {
+        if (this.config.authorization) {
+          queueItem.request.headers.authorization = this.config.authorization
+          queueItem.request.authorization = this.config.authorization
+        }
+        if (this.config.authtoken) {
+          queueItem.request.headers.authtoken = this.config.authtoken
+          queueItem.request.authtoken = this.config.authtoken
+        }
+      })
+      for (let i = 0; i < this.config.maxRequests; i++) {
+        this.initialShift()
+      }
+    })
+  }
   // Response interceptor used for
   const responseHandler = (response) => {
     response.config.onComplete()
@@ -150,7 +192,7 @@ export function ConcurrencyQueue ({ axios, config }) {
       } else {
         return Promise.reject(responseHandler(error))
       }
-    } else if (response.status === 429) {
+    } else if (response.status === 429 || (response.status === 401 && this.config.refreshToken)) {
       retryErrorType = `Error with status: ${response.status}`
       networkError++
 
@@ -159,7 +201,7 @@ export function ConcurrencyQueue ({ axios, config }) {
       }
       this.running.shift()
       // Cool down the running requests
-      delay(wait)
+      delay(wait, response.status === 401)
       error.config.retryCount = networkError
 
       return axios(updateRequestConfig(error, retryErrorType, wait))

lib/organization/index.js

@@ -220,7 +220,7 @@ export function Organization (http, data) {
     this.app = (uid = null) => {
       return new App(http, uid !== null ? { data: { uid, organization_uid: this.uid } } : { organization_uid: this.uid })
     }
-   } else {
+  } else {
     /**
      * @description The Get all organizations call lists all organizations related to the system user in the order that they were created.
      * @memberof Organization

test/unit/concurrency-Queue-test.js

@@ -9,6 +9,7 @@ import FormData from 'form-data'
 import { createReadStream } from 'fs'
 import path from 'path'
 import multiparty from 'multiparty'
+import { client } from '../../lib/contentstack'
 const axios = Axios.create()
 
 let server
@@ -60,10 +61,24 @@ const reconfigureQueue = (options = {}) => {
   concurrencyQueue = new ConcurrencyQueue({ axios: api, config })
 }
 var returnContent = false
+var unauthorized = false
+var token = 'Bearer <token_value_new>'
 describe('Concurrency queue test', () => {
   before(() => {
     server = http.createServer((req, res) => {
-      if (req.url === '/timeout') {
+      if (req.url === '/user-session') {
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ token }))
+      } else if (req.url === '/unauthorized') {
+        if (req.headers.authorization === token) {
+          res.writeHead(200, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ randomInteger: 123 }))
+        } else {
+          res.writeHead(401, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ errorCode: 401 }))
+        }
+        unauthorized = !unauthorized
+      } else if (req.url === '/timeout') {
         setTimeout(function () {
           res.writeHead(400, { 'Content-Type': 'application/json' })
           res.end()
@@ -111,6 +126,39 @@ describe('Concurrency queue test', () => {
     }
   })
 
+  it('Refresh Token on 401 with 1000 concurrent request', done => {
+    const axios2 = client({
+      baseURL: `${host}:${port}`
+    })
+    const axios = client({
+      baseURL: `${host}:${port}`,
+      authorization: 'Bearer <token_value>',
+      logHandler: logHandlerStub,
+      refreshToken: () => {
+        return new Promise((resolve, reject) => {
+          return axios2.login().then((res) => {
+            resolve({ authorization: res.token })
+          }).catch((error) => {
+            reject(error)
+          })
+        })
+      }
+    })
+    Promise.all(sequence(1003).map(() => axios.axiosInstance.get('/unauthorized')))
+      .then((responses) => {
+        return responses.map(r => r.config.headers.authorization)
+      })
+      .then(objects => {
+        objects.forEach((authorization) => {
+          expect(authorization).to.be.equal(token)
+        })
+        expect(logHandlerStub.callCount).to.be.equal(5)
+        expect(objects.length).to.be.equal(1003)
+        done()
+      })
+      .catch(done)
+  })
+
   it('Initialize with bad axios instance', done => {
     try {
       new ConcurrencyQueue({ axios: undefined })

types/contentstackClient.d.ts

@@ -18,10 +18,15 @@ export interface ProxyConfig {
 }
 export interface RetryDelayOption {
     base?: number
-    customBackoff: (retryCount: number, error: Error) => number
+    customBackoff?: (retryCount: number, error: Error) => number
 }
 
-export interface ContentstackConfig extends AxiosRequestConfig {
+export interface ContentstackToken {
+    authorization?: string
+    authtoken?: string
+}
+
+export interface ContentstackConfig extends AxiosRequestConfig, ContentstackToken {
     proxy?: ProxyConfig | false
     endpoint?: string
     host?: string
@@ -32,12 +37,12 @@ export interface ContentstackConfig extends AxiosRequestConfig {
     retryDelay?: number
     retryCondition?: (error: Error) => boolean
     retryDelayOptions?: RetryDelayOption
+    refreshToken?: () => ContentstackToken
     maxContentLength?: number
     maxBodyLength?: number
     logHandler?: (level: string, data: any) => void
     application?: string
     integration?: string
-    authtoken?: string
 }
 
 export interface LoginDetails {