Merge pull request #120 from contentstack/staging

DX | 18-08-2025 | Release

Author: harshithad0703

.talismanrc

@@ -6,4 +6,6 @@ fileignoreconfig:
   checksum: 34d28e7736ffac2b27d3708b6bca28591f3a930292433001d2397bfdf2d2fd0f
 - filename: .husky/pre-commit
   checksum: 5baabd7d2c391648163f9371f0e5e9484f8fb90fa2284cfc378732ec3192c193
+- filename: test/request.spec.ts
+  checksum: 87afd3bb570fd52437404cbe69a39311ad8a8c73bca9d075ecf88652fd3e13f6
 version: ""

CHANGELOG.md

@@ -1,4 +1,8 @@
 ## Change log
+### Version: 1.2.4
+#### Date: Aug-18-2025
+ - Fix: Retry request logic after rate limit replenishes
+
 ### Version: 1.2.3
 #### Date: Aug-04-2025
  - Fix: Added Pre-commit hook to run talisman and snyk scan

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/core",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "type": "commonjs",
   "main": "./dist/cjs/src/index.js",
   "types": "./dist/cjs/src/index.d.ts",

src/lib/retryPolicy/delivery-sdk-handlers.ts

@@ -45,8 +45,30 @@ export const retryResponseErrorHandler = (error: any, config: any, axiosInstance
       }
     } else {
       const rateLimitRemaining = response.headers['x-ratelimit-remaining'];
+
+      // Handle rate limit exhaustion with retry logic
       if (rateLimitRemaining !== undefined && parseInt(rateLimitRemaining) <= 0) {
-        return Promise.reject(error.response.data);
+        retryCount++;
+
+        if (retryCount >= config.retryLimit) {
+          return Promise.reject(error.response.data);
+        }
+
+        error.config.retryCount = retryCount;
+
+        // Calculate delay for rate limit reset
+        const rateLimitResetDelay = calculateRateLimitDelay(response.headers);
+
+        return new Promise((resolve, reject) => {
+          setTimeout(async () => {
+            try {
+              const retryResponse = await axiosInstance(error.config);
+              resolve(retryResponse);
+            } catch (retryError) {
+              reject(retryError);
+            }
+          }, rateLimitResetDelay);
+        });
       }
 
       if (response.status == 429 || response.status == 401) {
@@ -99,3 +121,41 @@ const retry = (error: any, config: any, retryCount: number, retryDelay: number,
     }, delayTime);
   });
 };
+
+/**
+ * Calculate delay time for rate limit reset based on response headers
+ * @param headers - Response headers from the API
+ * @returns Delay time in milliseconds
+ */
+export const calculateRateLimitDelay = (headers: any): number => {
+  // Check for retry-after header (in seconds)
+  const retryAfter = headers['retry-after'];
+  if (retryAfter) {
+    return parseInt(retryAfter) * 1000; // Convert to milliseconds
+  }
+
+  // Check for x-ratelimit-reset header (Unix timestamp)
+  const rateLimitReset = headers['x-ratelimit-reset'];
+  if (rateLimitReset) {
+    const resetTime = parseInt(rateLimitReset) * 1000; // Convert to milliseconds
+    const currentTime = Date.now();
+    const delay = resetTime - currentTime;
+
+    // Ensure we have a positive delay, add a small buffer
+    return Math.max(delay + 1000, 1000); // At least 1 second delay
+  }
+
+  // Check for x-ratelimit-reset-time header (ISO string)
+  const rateLimitResetTime = headers['x-ratelimit-reset-time'];
+  if (rateLimitResetTime) {
+    const resetTime = new Date(rateLimitResetTime).getTime();
+    const currentTime = Date.now();
+    const delay = resetTime - currentTime;
+
+    // Ensure we have a positive delay, add a small buffer
+    return Math.max(delay + 1000, 1000); // At least 1 second delay
+  }
+
+  // Default fallback delay (1 second) if no rate limit reset info is available
+  return 1000;
+};

test/request.spec.ts

@@ -111,4 +111,213 @@ describe('Request tests', () => {
     expect(mock.history.get[0].url).toBe(livePreviewURL);
     expect(result).toEqual(mockResponse);
   });
+
+  it('should throw error when response has no data property', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const responseWithoutData = { status: 200, headers: {} }; // Response without data property
+
+    // Mock response that returns undefined/empty data
+    mock.onGet(url).reply(() => [200, undefined, {}]);
+
+    await expect(getData(client, url)).rejects.toThrowError();
+  });
+
+  it('should throw error when response is null', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+
+    // Mock response that returns null
+    mock.onGet(url).reply(() => [200, null]);
+
+    await expect(getData(client, url)).rejects.toThrowError();
+  });
+
+  it('should handle live_preview when enable is false', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+
+    client.stackConfig = {
+      live_preview: {
+        enable: false, // Disabled
+        preview_token: 'someToken',
+        live_preview: 'someHash',
+        host: 'rest-preview.com',
+      },
+    };
+
+    mock.onGet(url).reply(200, mockResponse);
+
+    const result = await getData(client, url, {});
+    
+    // Should not modify URL when live preview is disabled
+    expect(mock.history.get[0].url).toBe(url);
+    expect(result).toEqual(mockResponse);
+  });
+
+  it('should handle request when stackConfig is undefined', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+
+    // No stackConfig set
+    client.stackConfig = undefined;
+
+    mock.onGet(url).reply(200, mockResponse);
+
+    const result = await getData(client, url, {});
+    expect(result).toEqual(mockResponse);
+  });
+
+  it('should handle request when stackConfig exists but live_preview is undefined', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+
+    client.stackConfig = {
+      // live_preview not defined
+      apiKey: 'test-key',
+    };
+
+    mock.onGet(url).reply(200, mockResponse);
+
+    const result = await getData(client, url, {});
+    expect(result).toEqual(mockResponse);
+  });
+
+  it('should set live_preview to "init" when enable is true and no live_preview provided', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+
+    client.stackConfig = {
+      live_preview: {
+        enable: true,
+        preview_token: 'someToken',
+        // live_preview not provided
+      },
+    };
+
+    mock.onGet(url).reply(200, mockResponse);
+
+    const data: any = {};
+    const result = await getData(client, url, data);
+    
+    // Should set live_preview to 'init'
+    expect(data.live_preview).toBe('init');
+    expect(result).toEqual(mockResponse);
+  });
+
+  it('should set headers when preview_token is provided', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+
+    client.stackConfig = {
+      live_preview: {
+        enable: true,
+        preview_token: 'test-preview-token',
+        live_preview: 'init',
+      },
+    };
+
+    mock.onGet(url).reply(200, mockResponse);
+
+    const result = await getData(client, url, {});
+    
+    // Should set headers
+    expect(client.defaults.headers.preview_token).toBe('test-preview-token');
+    expect(client.defaults.headers.live_preview).toBe('init');
+    expect(result).toEqual(mockResponse);
+  });
+
+  it('should handle live_preview when enable is true but no preview_token', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+
+    client.stackConfig = {
+      live_preview: {
+        enable: true,
+        live_preview: 'init',
+        // preview_token not provided
+      },
+    };
+
+    mock.onGet(url).reply(200, mockResponse);
+
+    const data: any = {};
+    const result = await getData(client, url, data);
+    
+    // Should still set live_preview in data
+    expect(data.live_preview).toBe('init');
+    expect(result).toEqual(mockResponse);
+  });
+
+  it('should handle custom error messages when request fails', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const customError = new Error('Custom network error');
+
+    mock.onGet(url).reply(() => {
+      throw customError;
+    });
+
+    await expect(getData(client, url)).rejects.toThrowError('Custom network error');
+  });
+
+  it('should handle non-Error objects as errors when they have message property', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const errorObject = { status: 500, message: 'Internal Server Error' };
+
+    mock.onGet(url).reply(() => {
+      throw errorObject;
+    });
+
+    // When error has message property, it uses the message
+    await expect(getData(client, url)).rejects.toThrowError('Internal Server Error');
+  });
+
+  it('should handle non-Error objects as errors when they have no message property', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const errorObject = { status: 500, code: 'SERVER_ERROR' };
+
+    mock.onGet(url).reply(() => {
+      throw errorObject;
+    });
+
+    // When error has no message property, it stringifies the object
+    await expect(getData(client, url)).rejects.toThrowError(JSON.stringify(errorObject));
+  });
+
+  it('should pass data parameter to axios get request', async () => {
+    const client = httpClient({});
+    const mock = new MockAdapter(client as any);
+    const url = '/your-api-endpoint';
+    const mockResponse = { data: 'mocked' };
+    const requestData = { params: { limit: 10, skip: 0 } };
+
+    mock.onGet(url).reply((config) => {
+      // Verify that data was passed correctly
+      expect(config.params).toEqual(requestData.params);
+      return [200, mockResponse];
+    });
+
+    const result = await getData(client, url, requestData);
+    expect(result).toEqual(mockResponse);
+  });
 });