feat: support variable request_timeout

CHANGELOG.md

@@ -1,4 +1,7 @@
 ## [unreleased]
+### Features
+- add support to define timeout per request using `request.timeout` or setting variable `request_timeout`
+
 ### Fix
 - variables in gql Query body are replaced (AnWeber/vscode-httpyac#303)
 - allow defaultHeaders to overwrite accept or user-agent header

src/models/httpRequest.ts

@@ -21,6 +21,7 @@ export interface Request<TMethod extends string = string, TBody = RequestBody> {
   noRejectUnauthorized?: boolean;
   noRedirect?: boolean;
   proxy?: string;
+  timeout?: number;
 }
 
 export interface HttpRequest extends Request<HttpMethod> {

src/plugins/core/request/setEnvRequestOptions.spec.ts

@@ -4,41 +4,59 @@ import { setEnvRequestOptions } from './setEnvRequestOptions';
 describe('setEnvRequestOptions', () => {
   describe('setEnvRequestOptions', () => {
     it('should set rejectUnauthorized=false', async () => {
-      const request: models.Request = { protocol: 'HTTP' };
+      const request: models.Request = { protocol: 'HTTP', url: 'url' };
       await setEnvRequestOptions(request, {
         variables: { request_rejectUnauthorized: false },
       } as unknown as models.ProcessorContext);
       expect(request.noRejectUnauthorized).toEqual(true);
     });
     it('should set rejectUnauthorized=false', async () => {
-      const request: models.Request = { protocol: 'HTTP' };
+      const request: models.Request = { protocol: 'HTTP', url: 'url' };
       await setEnvRequestOptions(request, {
         variables: { request_rejectUnauthorized: 'false' },
       } as unknown as models.ProcessorContext);
       expect(request.noRejectUnauthorized).toEqual(true);
     });
     it('should set rejectUnauthorized=true', async () => {
-      const request: models.Request = { protocol: 'HTTP' };
+      const request: models.Request = { protocol: 'HTTP', url: 'url' };
       await setEnvRequestOptions(request, {
         variables: { request_rejectUnauthorized: 'true' },
       } as unknown as models.ProcessorContext);
       expect(request.noRejectUnauthorized).toEqual(false);
     });
     it('should ignore rejectUnauthorized', async () => {
-      const request: models.Request = { protocol: 'HTTP' };
+      const request: models.Request = { protocol: 'HTTP', url: 'url' };
       await setEnvRequestOptions(request, {
         variables: {},
       } as unknown as models.ProcessorContext);
       expect(request.noRejectUnauthorized).toBeUndefined();
     });
     it('should set proxy', async () => {
-      const request: models.Request = { protocol: 'HTTP' };
+      const request: models.Request = { protocol: 'HTTP', url: 'url' };
       await setEnvRequestOptions(request, {
         variables: {
           request_proxy: 'http://localhost:8080',
         },
       } as unknown as models.ProcessorContext);
       expect(request.proxy).toBe('http://localhost:8080');
     });
+    it('should set proxy', async () => {
+      const request: models.Request = { protocol: 'HTTP', url: 'url' };
+      await setEnvRequestOptions(request, {
+        variables: {
+          request_proxy: 'http://localhost:8080',
+        },
+      } as unknown as models.ProcessorContext);
+      expect(request.proxy).toBe('http://localhost:8080');
+    });
+    it('should set timeout', async () => {
+      const request: models.Request = { protocol: 'HTTP', url: 'url' };
+      await setEnvRequestOptions(request, {
+        variables: {
+          request_timeout: '500',
+        },
+      } as unknown as models.ProcessorContext);
+      expect(request.timeout).toBe(500);
+    });
   });
 });

src/plugins/core/request/setEnvRequestOptions.ts

@@ -8,6 +8,7 @@ export async function setEnvRequestOptions(
   await setEnvRejectUnauthorized(request, variables);
   await setEnvNoRedirect(request, variables);
   await setEnvProxy(request, variables);
+  await setEnvRequestTimeout(request, variables);
 }
 
 async function setEnvRejectUnauthorized(request: models.Request, variables: models.Variables): Promise<void> {
@@ -31,3 +32,10 @@ async function setEnvProxy(request: models.Request, variables: models.Variables)
     request.proxy = variables.request_proxy;
   }
 }
+
+async function setEnvRequestTimeout(request: models.Request, variables: models.Variables): Promise<void> {
+  const timeout = utils.toNumber(variables?.request_timeout);
+  if (timeout !== undefined) {
+    request.timeout = timeout;
+  }
+}

src/plugins/grpc/callOptionsRequestHook.ts

@@ -6,7 +6,7 @@ export async function callOptionsRequestHook(request: models.Request, context: m
   if (isGrpcRequest(request) && request.headers) {
     utils.report(context, 'create call options');
     if (context.config?.request?.timeout) {
-      const timeout = utils.toNumber(context.config?.request?.timeout) || 0;
+      const timeout = request.timeout || utils.toNumber(context.config?.request?.timeout) || 0;
       request.callOptions = Object.assign({}, request.options, {
         deadline: new Date(new Date().getTime() + timeout),
       });

src/plugins/http/gotUtils.ts

@@ -45,6 +45,7 @@ export function getClientOptions(
       method: request.method,
       headers: request.headers,
       body: request.body,
+      timeout: request.timeout,
     },
     request.options
   );

src/plugins/mqtt/mqttRequestClient.ts

@@ -151,8 +151,9 @@ export class MQTTRequestClient extends models.AbstractRequestClient<MqttClient |
 
     const configOptions: IClientOptions = {};
     if (config?.request) {
-      if (config.request.timeout !== undefined) {
-        configOptions.connectTimeout = utils.toNumber(config.request.timeout);
+      const timeout = request.timeout || utils.toNumber(config.request.timeout);
+      if (timeout !== undefined) {
+        configOptions.connectTimeout = timeout;
       }
       if (!utils.isUndefined(config.request.rejectUnauthorized)) {
         configOptions.rejectUnauthorized = utils.toBoolean(config.request.rejectUnauthorized, true);

src/plugins/websocket/websocketRequestClient.ts

@@ -156,7 +156,8 @@ export class WebsocketRequestClient extends models.AbstractRequestClient<WebSock
 
     const configOptions: ClientOptions = {};
     if (config?.request) {
-      configOptions.handshakeTimeout = utils.toNumber(config.request.timeout);
+      configOptions.handshakeTimeout = request.timeout || utils.toNumber(config.request.timeout);
+      configOptions.sessionTimeout = configOptions.handshakeTimeout;
       if (!utils.isUndefined(config.request.rejectUnauthorized)) {
         configOptions.rejectUnauthorized = utils.toBoolean(config.request.rejectUnauthorized, true);
       }