Add rate limit header wrapper for all API responses

Introduce AdoHttpClient and AdoRestClient wrappers that automatically
extract rate limit headers and attach them as a rateLimit property on
response objects. This avoids needing to regenerate all API clients.

- Add RateLimitUtils.ts with shared extractRateLimitHeaders function
- Add AdoHttpClientBases.ts with AdoHttpClient and AdoRestClient wrappers
- Update ClientApiBases.ts and WebApi.ts to use new wrappers
- Add unit test for rate limit header extraction
- Bump version to 15.1.4

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: csumana19

api/AdoHttpClientBases.ts

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { extractRateLimitHeaders } from './RateLimitUtils';
+
+import * as rm from 'typed-rest-client/RestClient';
+import * as hm from 'typed-rest-client/HttpClient';
+import { IHeaders, IHttpClientResponse } from 'typed-rest-client/Interfaces';
+
+/**
+ * AdoHttpClient that extracts rate limit headers and attaches them to the response object
+ */
+export class AdoHttpClient extends hm.HttpClient {
+    public async request(verb: string, requestUrl: string, data: string | NodeJS.ReadableStream, headers: IHeaders): Promise<IHttpClientResponse> {
+        const res = await super.request(verb, requestUrl, data, headers);
+
+        const resHeaders = res?.message?.headers;
+
+        extractRateLimitHeaders(resHeaders, res);
+        extractRateLimitHeaders(resHeaders, res?.message);
+
+        return res;
+    }
+}
+
+/**
+ * AdoRestClient that extracts rate limit headers and attaches them to the response/result objects
+ */
+export class AdoRestClient extends rm.RestClient {
+    protected async processResponse<T>(res: hm.HttpClientResponse, options: rm.IRequestOptions): Promise<rm.IRestResponse<T>> {
+        const headers = res?.message?.headers;
+
+        try {
+            const response = await super.processResponse(res, options);
+            if (response && response.result && typeof response.result === 'object') {
+                extractRateLimitHeaders(headers, response.result);
+            }
+            return response as rm.IRestResponse<T>;
+        } catch (err: any) {
+            // Use the original response headers captured before super.processResponse,
+            // because the base implementation may not populate err.responseHeaders
+            // when the response body is not valid JSON (e.g., HTML error pages on 429).
+            extractRateLimitHeaders(headers, err);
+            if (err?.result && typeof err.result === 'object') {
+                extractRateLimitHeaders(headers, err.result);
+            }
+            return Promise.reject(err);
+        }
+    }
+}

api/ClientApiBases.ts

@@ -4,6 +4,8 @@
 import vsom = require('./VsoClient');
 import VsoBaseInterfaces = require('./interfaces/common/VsoBaseInterfaces');
 import serm = require('./Serialization');
+import AdoHttpClientBases = require('./AdoHttpClientBases');
+import { extractRateLimitHeaders } from './RateLimitUtils';
 import * as rm from 'typed-rest-client/RestClient';
 import * as hm from 'typed-rest-client/HttpClient';
 
@@ -20,8 +22,8 @@ export class ClientApiBase {
     constructor(baseUrl: string, handlers: VsoBaseInterfaces.IRequestHandler[], userAgent: string, options?: VsoBaseInterfaces.IRequestOptions) {
         this.baseUrl = baseUrl;
 
-        this.http = new hm.HttpClient(userAgent, handlers, options);
-        this.rest = new rm.RestClient(userAgent, null, handlers, options);
+        this.http = new AdoHttpClientBases.AdoHttpClient(userAgent, handlers, options);
+        this.rest = new AdoHttpClientBases.AdoRestClient(userAgent, null, handlers, options);
 
         this.vsoClient = new vsom.VsoClient(baseUrl, this.rest);
         this.userAgent = userAgent;
@@ -50,30 +52,6 @@ export class ClientApiBase {
     }
 
     public extractRateLimitHeaders(headers: any, target: any): void {
-        if (!headers || !target) {
-            return;
-        }
-
-        const rateLimit: VsoBaseInterfaces.RateLimit = {};
-
-        if (headers['x-ratelimit-resource']) {
-            rateLimit.resource = headers['x-ratelimit-resource'];
-        }
-        if (headers['x-ratelimit-delay']) {
-            rateLimit.delay = parseFloat(headers['x-ratelimit-delay']);
-        }
-        if (headers['x-ratelimit-limit']) {
-            rateLimit.limit = parseInt(headers['x-ratelimit-limit'], 10);
-        }
-        if (headers['x-ratelimit-remaining']) {
-            rateLimit.remaining = parseInt(headers['x-ratelimit-remaining'], 10);
-        }
-        if (headers['x-ratelimit-reset']) {
-            rateLimit.reset = parseInt(headers['x-ratelimit-reset'], 10);
-        }
-        if (headers['retry-after']) {
-            rateLimit.retryAfter = parseInt(headers['retry-after'], 10);
-        }
-        target.rateLimit = rateLimit;
+        extractRateLimitHeaders(headers, target);
     }
 }

api/RateLimitUtils.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import VsoBaseInterfaces = require('./interfaces/common/VsoBaseInterfaces');
+
+/**
+ * Extracts rate limit headers from the provided headers and attaches them to the target object
+ * @param headers - source headers
+ * @param target - target object to attach rate limit info to
+ */
+export function extractRateLimitHeaders(headers: any, target: any): void {
+    if (!headers || !target) {
+        return;
+    }
+
+    const rateLimit: VsoBaseInterfaces.RateLimit = {};
+
+    if (headers['x-ratelimit-resource']) {
+        rateLimit.resource = headers['x-ratelimit-resource'];
+    }
+    if (headers['x-ratelimit-delay']) {
+        rateLimit.delay = parseFloat(headers['x-ratelimit-delay']);
+    }
+    if (headers['x-ratelimit-limit']) {
+        rateLimit.limit = parseInt(headers['x-ratelimit-limit'], 10);
+    }
+    if (headers['x-ratelimit-remaining']) {
+        rateLimit.remaining = parseInt(headers['x-ratelimit-remaining'], 10);
+    }
+    if (headers['x-ratelimit-reset']) {
+        rateLimit.reset = parseInt(headers['x-ratelimit-reset'], 10);
+    }
+    if (headers['retry-after']) {
+        rateLimit.retryAfter = parseInt(headers['retry-after'], 10);
+    }
+    target.rateLimit = rateLimit;
+}

api/WebApi.ts

@@ -37,7 +37,7 @@ import basicm = require('./handlers/basiccreds');
 import bearm = require('./handlers/bearertoken');
 import ntlmm = require('./handlers/ntlm');
 import patm = require('./handlers/personalaccesstoken');
-
+import AdoHttpClientBases = require('./AdoHttpClientBases');
 import * as rm from 'typed-rest-client/RestClient';
 import vsom = require('./VsoClient');
 import lim = require("./interfaces/LocationsInterfaces");
@@ -172,7 +172,7 @@ export class WebApi {
                 userAgent = `${nodeApiName}/${nodeApiVersion} (${osName} ${osVersion})`;
             }
         }
-        this.rest = new rm.RestClient(userAgent, null, [this.authHandler], this.options);
+        this.rest = new AdoHttpClientBases.AdoRestClient(userAgent, null, [this.authHandler], this.options);
         this.vsoClient = new vsom.VsoClient(defaultUrl, this.rest);
     }
 

package-lock.json

@@ -1,7 +1,7 @@
 {
     "name": "azure-devops-node-api",
     "description": "Node client for Azure DevOps and TFS REST APIs",
-    "version": "15.1.3",
+    "version": "15.1.4",
     "main": "./WebApi.js",
     "types": "./WebApi.d.ts",
     "scripts": {

package.json

@@ -5,8 +5,9 @@ import os = require('os');
 import vsom = require('../../_build/VsoClient');
 import WebApi = require('../../_build/WebApi');
 import * as rm from 'typed-rest-client/RestClient';
-import { ApiResourceLocation } from '../../_build/interfaces/common/VsoBaseInterfaces';
+import { ApiResourceLocation, RateLimit } from '../../_build/interfaces/common/VsoBaseInterfaces';
 import semver = require('semver');
+import { IRestResponse } from 'typed-rest-client';
 
 describe('VSOClient Units', function () {
     let rest: rm.RestClient;
@@ -316,6 +317,42 @@ describe('WebApi Units', function () {
         assert.equal(userAgent, myWebApi.rest.client.userAgent, 'User agent should be: ' + userAgent);
     });
 
+    it('AdoRestClient attaches rate limit headers to responses', async () => {
+        // Arrange
+        const userAgent: string = `${nodeApiName}/${nodeApiVersion} (${osName} ${osVersion})`;
+
+        nock('https://dev.azure.com', {
+            reqheaders: {
+                'accept': 'application/json',
+                'user-agent': userAgent,
+            },
+        })
+            .defaultReplyHeaders({
+                'x-ratelimit-resource': 'core',
+                'x-ratelimit-delay': '0.5',
+                'x-ratelimit-limit': '1000',
+                'x-ratelimit-remaining': '999',
+                'x-ratelimit-reset': '1625078400',
+                'retry-after': '1',
+            })
+            .get('/test')
+            .reply(200, { success: true });
+        
+        const myWebApi: WebApi.WebApi = new WebApi.WebApi('https://dev.azure.com', WebApi.getBasicHandler('user', 'password'));
+
+        // Act
+        const response = (await myWebApi.rest.get<{ success: boolean, rateLimit?: RateLimit }>('https://dev.azure.com/test')) as IRestResponse<{ success: boolean, rateLimit?: RateLimit }>;
+        // Assert
+        assert(response.result?.success === true, 'Response body should indicate success');
+        assert(response.result?.rateLimit, 'Response should have rateLimit property');
+        assert.equal(response.result.rateLimit?.resource, 'core', 'Rate limit resource should be "core"');
+        assert.equal(response.result.rateLimit?.delay, 0.5, 'Rate limit delay should be 0.5');
+        assert.equal(response.result.rateLimit?.limit, 1000, 'Rate limit limit should be 1000');
+        assert.equal(response.result.rateLimit?.remaining, 999, 'Rate limit remaining should be 999');
+        assert.equal(response.result.rateLimit?.reset, 1625078400, 'Rate limit reset should be 1625078400');
+        assert.equal(response.result.rateLimit?.retryAfter, 1, 'Rate limit retryAfter should be 1');
+    });
+
     it('sets the user agent correctly when request settings are not specified', async () => {
         const myWebApi: WebApi.WebApi = new WebApi.WebApi('https://microsoft.com', WebApi.getBasicHandler('user', 'password'), undefined);
         const userAgent: string = `${nodeApiName}/${nodeApiVersion} (${osName} ${osVersion})`;