Merge origin/master (PR #504 hotfix DX-4429) into feat/dam-2.0-test-cases

Author: AniketDev7

.talismanrc

@@ -1,4 +1,6 @@
 fileignoreconfig:
+  - filename: lib/contentstackClient.js
+    checksum: f564f6eee5c17dc73abdeab4be226a3b37942893e149d907d2a4ef415c485c5e
   - filename: test/unit/globalField-test.js
     checksum: 25185e3400a12e10a043dc47502d8f30b7e1c4f2b6b4d3b8b55cdc19850c48bf
   - filename: lib/stack/index.js
@@ -7,7 +9,9 @@ fileignoreconfig:
     ignore_detectors:
       - filecontent
   - filename: package-lock.json
-    checksum: 17b5bbabcc58beaa180a7fa931fc3fb407ee0e3447d47da224f60118c0a4c294
+    checksum: 92b88ce00603ede68344bac6bd6bf76bdb76f1e5f5ba8d1d0c79da2b72c5ecc0
+  - filename: test/unit/ContentstackClient-test.js
+    checksum: 5d8519b5b93c715e911a62b4033614cc4fb3596eabf31c7216ecb4cc08604a73
   - filename: .husky/pre-commit
     checksum: 52a664f536cf5d1be0bea19cb6031ca6e8107b45b6314fe7d47b7fad7d800632
   - filename: lib/stack/asset/index.js
@@ -18,10 +22,6 @@ fileignoreconfig:
     checksum: b506f33bffdd20dfc701f964370707f5d7b28a2c05c70665f0edb7b3c53c165b
   - filename: examples/robust-error-handling.js
     checksum: e8a32ffbbbdba2a15f3d327273f0a5b4eb33cf84cd346562596ab697125bbbc6
-  - filename: lib/contentstackClient.js
-    checksum: b76ca091caa3a1b2658cd422a2d8ef3ac9996aea0aff3f982d56bb309a3d9fde
-  - filename: test/unit/ContentstackClient-test.js
-    checksum: 974a4f335aef025b657d139bb290233a69bed1976b947c3c674e97baffe4ce2f
   - filename: test/unit/ContentstackHTTPClient-test.js
     checksum: 4043efd843e24da9afd0272c55ef4b0432e3374b2ca12b913f1a6654df3f62be
   - filename: test/unit/contentstack-test.js
@@ -105,4 +105,6 @@ fileignoreconfig:
     checksum: 1ba486167f2485853d9574322c233d28fc566e02db44bb9831b70fb9afaf7631
   - filename: test/sanity-check/mock/index.js
     checksum: 6c0d8f6e7c85cd2fa5f0a20e8a49e94df0dde1b2c1d7e9c39e8c9c6c8b8d5e2f1
+  - filename: test/unit/concurrency-Queue-test.js
+    checksum: fd5c327f4fa1b334fdb1a2d903ac0213752e7829f31f19667215aa186c3efbbf
 version: "1.0"

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [v1.27.5](https://github.com/contentstack/contentstack-management-javascript/tree/v1.27.5) (2026-02-11)
+ - Fix
+   - Concurrency queue: when response errors have no `config` (e.g. after network retries exhaust in some environments, or when plugins return a new error object), the SDK now rejects with a catchable Error instead of throwing an unhandled TypeError and crashing the process
+   - Hardened `responseHandler` to safely handle errors without `config` (e.g. plugin-replaced errors) by guarding `config.onComplete` and still running queue `shift()` so rejections remain catchable
+   - Added optional chaining for `error.config` reads in the retry path and unit tests for missing-config scenarios
+
+## [v1.27.4](https://github.com/contentstack/contentstack-management-javascript/tree/v1.27.4) (2026-02-02)
+ - Fix
+   - Removed content-type header from the release delete method
+   - Plugin `onResponse` hook is now called for error responses; errors handled by the concurrency queue (e.g. 5xx, retries exhausted) were previously not running plugin hooks
+
+## [v1.27.3](https://github.com/contentstack/contentstack-management-javascript/tree/v1.27.3) (2026-01-21)
+ - Fix
+   - Skip token refresh and preserve error_code 294 when 2FA is required (error_code 294 with 401 status) to prevent error code conversion from 294 to 401
+
 ## [v1.27.2](https://github.com/contentstack/contentstack-management-javascript/tree/v1.27.2) (2026-01-12)
  - Enhancement
    - Improved error messages

lib/core/concurrency-queue.js

@@ -52,7 +52,7 @@ const defaultConfig = {
  * @returns {Object} ConcurrencyQueue instance with request/response interceptors attached to Axios.
  * @throws {Error} If axios instance is not provided or configuration is invalid.
  */
-export function ConcurrencyQueue ({ axios, config }) {
+export function ConcurrencyQueue ({ axios, config, plugins = [] }) {
   if (!axios) {
     throw Error(ERROR_MESSAGES.AXIOS_INSTANCE_MISSING)
   }
@@ -172,7 +172,7 @@ export function ConcurrencyQueue ({ axios, config }) {
       logFinalFailure(errorInfo, this.config.maxNetworkRetries)
       // Final error message
       const finalError = new Error(`Network request failed after ${this.config.maxNetworkRetries} retries: ${errorInfo.reason}`)
-      finalError.code = error.code
+      finalError.code = error && error.code
       finalError.originalError = error
       finalError.retryAttempts = attempt - 1
       return Promise.reject(finalError)
@@ -181,6 +181,16 @@ export function ConcurrencyQueue ({ axios, config }) {
     const delay = calculateNetworkRetryDelay(attempt)
     logRetryAttempt(errorInfo, attempt, delay)
 
+    // Guard: retry failures (e.g. from nested retries) may not have config in some
+    // environments. Reject with a catchable error instead of throwing TypeError.
+    if (!error || !error.config) {
+      const finalError = new Error(`Network request failed after retries: ${errorInfo.reason}`)
+      finalError.code = error && error.code
+      finalError.originalError = error
+      finalError.retryAttempts = attempt - 1
+      return Promise.reject(finalError)
+    }
+
     // Initialize retry count if not present
     if (!error.config.networkRetryCount) {
       error.config.networkRetryCount = 0
@@ -200,9 +210,7 @@ export function ConcurrencyQueue ({ axios, config }) {
         safeAxiosRequest(requestConfig)
           .then((response) => {
             // On successful retry, call the original onComplete to properly clean up
-            if (error.config.onComplete) {
-              error.config.onComplete()
-            }
+            error?.config?.onComplete?.()
             shift() // Process next queued request
             resolve(response)
           })
@@ -214,17 +222,13 @@ export function ConcurrencyQueue ({ axios, config }) {
                 .then(resolve)
                 .catch((finalError) => {
                   // On final failure, clean up the running queue
-                  if (error.config.onComplete) {
-                    error.config.onComplete()
-                  }
+                  error?.config?.onComplete?.()
                   shift() // Process next queued request
                   reject(finalError)
                 })
             } else {
               // On non-retryable error, clean up the running queue
-              if (error.config.onComplete) {
-                error.config.onComplete()
-              }
+              error?.config?.onComplete?.()
               shift() // Process next queued request
               reject(retryError)
             }
@@ -429,50 +433,101 @@ export function ConcurrencyQueue ({ axios, config }) {
       }
     })
   }
-  // Response interceptor used for
+  // Response interceptor used for success and for error path (Promise.reject(responseHandler(err))).
+  // When used with an error, err may lack config (e.g. plugin returns new error). Guard so we don't throw.
   const responseHandler = (response) => {
-    response.config.onComplete()
+    if (response?.config?.onComplete) {
+      response.config.onComplete()
+    }
     shift()
     return response
   }
 
+  // Run plugin onResponse hooks for errors so plugins see every error (including
+  // those that are rejected without going through the plugin response interceptor).
+  const runPluginOnResponseForError = (error) => {
+    if (!plugins || !plugins.length) return error
+    let currentError = error
+    for (const plugin of plugins) {
+      try {
+        if (typeof plugin.onResponse === 'function') {
+          const result = plugin.onResponse(currentError)
+          if (result !== undefined) currentError = result
+        }
+      } catch (e) {
+        if (this.config.logHandler) {
+          this.config.logHandler('error', {
+            name: 'PluginError',
+            message: `Error in plugin onResponse (error handler): ${e.message}`,
+            error: e
+          })
+        }
+      }
+    }
+    return currentError
+  }
+
   const responseErrorHandler = error => {
-    let networkError = error.config.retryCount
+    // Guard: Axios errors normally have config; missing config can occur when a retry
+    // fails in certain environments or when non-Axios errors propagate (e.g. timeouts).
+    // Reject with a catchable error instead of throwing TypeError and crashing the process.
+    if (!error || !error.config) {
+      const fallbackError = new Error(
+        error && typeof error.message === 'string'
+          ? error.message
+          : 'Network request failed: error object missing request config'
+      )
+      fallbackError.code = error?.code
+      fallbackError.originalError = error
+      return Promise.reject(runPluginOnResponseForError(fallbackError))
+    }
+
+    let networkError = error?.config?.retryCount ?? 0
     let retryErrorType = null
 
     // First, check for transient network errors
     const networkErrorInfo = isTransientNetworkError(error)
     if (networkErrorInfo && this.config.retryOnNetworkFailure) {
-      const networkRetryCount = error.config.networkRetryCount || 0
+      const networkRetryCount = error?.config?.networkRetryCount || 0
       return retryNetworkError(error, networkErrorInfo, networkRetryCount + 1)
     }
 
     // Original retry logic for non-network errors
     if (!this.config.retryOnError || networkError > this.config.retryLimit) {
-      return Promise.reject(responseHandler(error))
+      const err = runPluginOnResponseForError(error)
+      return Promise.reject(responseHandler(err))
     }
 
     // Check rate limit remaining header before retrying
     const wait = this.config.retryDelay
     var response = error.response
     if (!response) {
       if (error.code === 'ECONNABORTED') {
-        const timeoutMs = error.config.timeout || this.config.timeout || 'unknown'
+        const timeoutMs = error?.config?.timeout || this.config.timeout || 'unknown'
         error.response = {
           ...error.response,
           status: 408,
           statusText: `timeout of ${timeoutMs}ms exceeded`
         }
         response = error.response
       } else {
-        return Promise.reject(responseHandler(error))
+        const err = runPluginOnResponseForError(error)
+        return Promise.reject(responseHandler(err))
       }
     } else if ((response.status === 401 && this.config.refreshToken)) {
+      // If error_code is 294 (2FA required), don't retry/refresh - pass through the error as-is
+      const apiErrorCode = response.data?.error_code
+      if (apiErrorCode === 294) {
+        const err = runPluginOnResponseForError(error)
+        return Promise.reject(responseHandler(err))
+      }
+
       retryErrorType = `Error with status: ${response.status}`
       networkError++
 
       if (networkError > this.config.retryLimit) {
-        return Promise.reject(responseHandler(error))
+        const err = runPluginOnResponseForError(error)
+        return Promise.reject(responseHandler(err))
       }
       this.running.shift()
       // Cool down the running requests
@@ -486,19 +541,22 @@ export function ConcurrencyQueue ({ axios, config }) {
       networkError++
       return this.retry(error, retryErrorType, networkError, wait)
     }
-    return Promise.reject(responseHandler(error))
+    const err = runPluginOnResponseForError(error)
+    return Promise.reject(responseHandler(err))
   }
 
   this.retry = (error, retryErrorType, retryCount, waittime) => {
     let delaytime = waittime
     if (retryCount > this.config.retryLimit) {
-      return Promise.reject(responseHandler(error))
+      const err = runPluginOnResponseForError(error)
+      return Promise.reject(responseHandler(err))
     }
     if (this.config.retryDelayOptions) {
       if (this.config.retryDelayOptions.customBackoff) {
         delaytime = this.config.retryDelayOptions.customBackoff(retryCount, error)
         if (delaytime && delaytime <= 0) {
-          return Promise.reject(responseHandler(error))
+          const err = runPluginOnResponseForError(error)
+          return Promise.reject(responseHandler(err))
         }
       } else if (this.config.retryDelayOptions.base) {
         delaytime = this.config.retryDelayOptions.base * retryCount

lib/core/contentstackHTTPClient.js

@@ -109,10 +109,11 @@ export default function contentstackHttpClient (options) {
   }
   const instance = axios.create(axiosOptions)
   instance.httpClientParams = options
-  instance.concurrencyQueue = new ConcurrencyQueue({ axios: instance, config })
 
-  // Normalize and store plugins
-  const plugins = normalizePlugins(config.plugins)
+  // Normalize and store plugins before ConcurrencyQueue so plugin interceptors
+  // run after the queue's (plugin sees responses/errors before they reach the queue).
+  // Use options.plugins so hooks run against the same plugin references (spies work in tests).
+  const plugins = normalizePlugins(options.plugins || config.plugins)
 
   // Request interceptor for versioning strategy (must run first)
   instance.interceptors.request.use((request) => {
@@ -235,5 +236,7 @@ export default function contentstackHttpClient (options) {
     )
   }
 
+  instance.concurrencyQueue = new ConcurrencyQueue({ axios: instance, config, plugins })
+
   return instance
 }

lib/stack/release/index.js

@@ -3,7 +3,6 @@ import {
   create,
   fetch,
   update,
-  deleteEntity,
   query
 } from '../../entity'
 import error from '../../core/contentstackError'
@@ -94,7 +93,31 @@ export function Release (http, data = {}) {
      * client.stack({ api_key: 'api_key'}).release('release_uid').delete()
      * .then((response) => console.log(response.notice))
      */
-    this.delete = deleteEntity(http)
+    this.delete = (function (http) {
+      return async function (param = {}) {
+        try {
+          const requestConfig = {
+            headers: { ...cloneDeep(this.stackHeaders) },
+            params: { ...cloneDeep(param) }
+          }
+          // Omit Content-Type for DELETE; no body is sent and fastify v5 rejects it when present
+          requestConfig.headers['Content-Type'] = null
+          const response = await http.delete(this.urlPath, requestConfig)
+          if (response.data) {
+            return response.data
+          }
+          if (response.status >= 200 && response.status < 300) {
+            return {
+              status: response.status,
+              statusText: response.statusText
+            }
+          }
+          throw error(response)
+        } catch (err) {
+          throw error(err)
+        }
+      }
+    })(http)
 
     /**
      * @description A ReleaseItem is a set of entries and assets that needs to be deployed (published or unpublished) all at once to a particular environment.