Add http client component to runtime extension

.changeset/three-nails-press.md

@@ -0,0 +1,8 @@
+---
+"@smithy/fetch-http-handler": minor
+"@smithy/node-http-handler": minor
+"@smithy/protocol-http": minor
+"@smithy/util-test": minor
+---
+
+Add http client component to runtime extension

packages/fetch-http-handler/src/fetch-http-handler.spec.ts

@@ -55,6 +55,54 @@ describe(FetchHttpHandler.name, () => {
     expect(await blobToText(response.response.body)).toBe("FOO");
   });
 
+  it("put HttpClientConfig", async () => {
+    const mockResponse = {
+      headers: {
+        entries: jest.fn().mockReturnValue([
+          ["foo", "bar"],
+          ["bizz", "bazz"],
+        ]),
+      },
+      blob: jest.fn().mockResolvedValue(new Blob(["FOO"])),
+    };
+    const mockFetch = jest.fn().mockResolvedValue(mockResponse);
+
+    (global as any).fetch = mockFetch;
+    const fetchHttpHandler = new FetchHttpHandler();
+    fetchHttpHandler.updateHttpClientConfig("requestTimeout", 200);
+
+    await fetchHttpHandler.handle({} as any, {});
+
+    expect(fetchHttpHandler.httpHandlerConfigs().requestTimeout).toBe(200);
+  });
+
+  it("update HttpClientConfig", async () => {
+    const mockResponse = {
+      headers: {
+        entries: jest.fn().mockReturnValue([
+          ["foo", "bar"],
+          ["bizz", "bazz"],
+        ]),
+      },
+      blob: jest.fn().mockResolvedValue(new Blob(["FOO"])),
+    };
+    const mockFetch = jest.fn().mockResolvedValue(mockResponse);
+
+    (global as any).fetch = mockFetch;
+    const fetchHttpHandler = new FetchHttpHandler({ requestTimeout: 200 });
+    fetchHttpHandler.updateHttpClientConfig("requestTimeout", 300);
+
+    await fetchHttpHandler.handle({} as any, {});
+
+    expect(fetchHttpHandler.httpHandlerConfigs().requestTimeout).toBe(300);
+  });
+
+  it("httpHandlerConfigs returns empty object if handle is not called", async () => {
+    const fetchHttpHandler = new FetchHttpHandler();
+    fetchHttpHandler.updateHttpClientConfig("requestTimeout", 300);
+    expect(fetchHttpHandler.httpHandlerConfigs()).toEqual({});
+  });
+
   it("defaults to response.blob for response.body = null", async () => {
     const mockResponse = {
       body: null,

packages/fetch-http-handler/src/fetch-http-handler.ts

@@ -19,11 +19,11 @@ export interface FetchHttpHandlerOptions {
 
 type FetchHttpHandlerConfig = FetchHttpHandlerOptions;
 
-export class FetchHttpHandler implements HttpHandler {
+export class FetchHttpHandler implements HttpHandler<FetchHttpHandlerConfig> {
   private config?: FetchHttpHandlerConfig;
-  private readonly configProvider: Promise<FetchHttpHandlerConfig>;
+  private configProvider: Promise<FetchHttpHandlerConfig>;
 
-  constructor(options?: FetchHttpHandlerOptions | Provider<FetchHttpHandlerOptions | undefined>) {
+  constructor(options?: FetchHttpHandlerOptions | Provider<FetchHttpHandlerOptions | void>) {
     if (typeof options === "function") {
       this.configProvider = options().then((opts) => opts || {});
     } else {
@@ -130,4 +130,16 @@ export class FetchHttpHandler implements HttpHandler {
     }
     return Promise.race(raceOfPromises);
   }
+
+  updateHttpClientConfig(key: keyof FetchHttpHandlerConfig, value: FetchHttpHandlerConfig[typeof key]): void {
+    this.config = undefined;
+    this.configProvider = this.configProvider.then((resolveConfig) => {
+      resolveConfig[key] = value;
+      return resolveConfig;
+    });
+  }
+
+  httpHandlerConfigs(): FetchHttpHandlerConfig {
+    return this.config ?? {};
+  }
 }

packages/node-http-handler/src/node-http-handler.spec.ts

@@ -640,4 +640,68 @@ describe("NodeHttpHandler", () => {
       expect(nodeHttpHandler.destroy()).toBeUndefined();
     });
   });
+
+  describe("configs", () => {
+    const mockResponse = {
+      statusCode: 200,
+      statusText: "OK",
+      headers: {},
+      body: "test",
+    };
+
+    let mockHttpServer: HttpServer;
+    let request: HttpRequest;
+
+    beforeAll(() => {
+      mockHttpServer = createMockHttpServer().listen(54320);
+      request = new HttpRequest({
+        hostname: "localhost",
+        method: "GET",
+        port: (mockHttpServer.address() as AddressInfo).port,
+        protocol: "http:",
+        path: "/",
+        headers: {},
+      });
+    });
+
+    afterEach(() => {
+      mockHttpServer.removeAllListeners("request");
+      mockHttpServer.removeAllListeners("checkContinue");
+    });
+
+    afterAll(() => {
+      mockHttpServer.close();
+    });
+
+    it("put HttpClientConfig", async () => {
+      mockHttpServer.addListener("request", createResponseFunction(mockResponse));
+
+      const nodeHttpHandler = new NodeHttpHandler();
+      const requestTimeout = 200;
+
+      nodeHttpHandler.updateHttpClientConfig("requestTimeout", requestTimeout);
+
+      await nodeHttpHandler.handle(request, {});
+
+      expect(nodeHttpHandler.httpHandlerConfigs().requestTimeout).toEqual(requestTimeout);
+    });
+
+    it("update existing HttpClientConfig", async () => {
+      mockHttpServer.addListener("request", createResponseFunction(mockResponse));
+
+      const nodeHttpHandler = new NodeHttpHandler({ requestTimeout: 200 });
+      const requestTimeout = 300;
+
+      nodeHttpHandler.updateHttpClientConfig("requestTimeout", requestTimeout);
+
+      await nodeHttpHandler.handle(request, {});
+
+      expect(nodeHttpHandler.httpHandlerConfigs().requestTimeout).toEqual(requestTimeout);
+    });
+
+    it("httpHandlerConfigs returns empty object if handle is not called", async () => {
+      const nodeHttpHandler = new NodeHttpHandler();
+      expect(nodeHttpHandler.httpHandlerConfigs()).toEqual({});
+    });
+  });
 });

packages/node-http-handler/src/node-http-handler.ts

@@ -50,9 +50,9 @@ interface ResolvedNodeHttpHandlerConfig {
 
 export const DEFAULT_REQUEST_TIMEOUT = 0;
 
-export class NodeHttpHandler implements HttpHandler {
+export class NodeHttpHandler implements HttpHandler<NodeHttpHandlerOptions> {
   private config?: ResolvedNodeHttpHandlerConfig;
-  private readonly configProvider: Promise<ResolvedNodeHttpHandlerConfig>;
+  private configProvider: Promise<ResolvedNodeHttpHandlerConfig>;
 
   // Node http handler is hard-coded to http/1.1: https://github.com/nodejs/node/blob/ff5664b83b89c55e4ab5d5f60068fb457f1f5872/lib/_http_server.js#L286
   public readonly metadata = { handlerProtocol: "http/1.1" };
@@ -192,4 +192,18 @@ export class NodeHttpHandler implements HttpHandler {
       writeRequestBodyPromise = writeRequestBody(req, request, this.config.requestTimeout).catch(_reject);
     });
   }
+
+  updateHttpClientConfig(key: keyof NodeHttpHandlerOptions, value: NodeHttpHandlerOptions[typeof key]): void {
+    this.config = undefined;
+    this.configProvider = this.configProvider.then((resolveConfig) => {
+      return {
+        ...resolveConfig,
+        [key]: value,
+      };
+    });
+  }
+
+  httpHandlerConfigs(): NodeHttpHandlerOptions {
+    return this.config ?? {};
+  }
 }

packages/node-http-handler/src/node-http2-handler.spec.ts

@@ -643,4 +643,55 @@ describe(NodeHttp2Handler.name, () => {
     } as any);
     handler.destroy();
   });
+
+  it("put HttpClientConfig", async () => {
+    const server = createMockHttp2Server();
+    server.on("request", (request, response) => {
+      expect(request.url).toBe("http://foo:bar@localhost/");
+      response.statusCode = 200;
+    });
+    const handler = new NodeHttp2Handler({});
+
+    const requestTimeout = 200;
+
+    handler.updateHttpClientConfig("requestTimeout", requestTimeout);
+
+    await handler.handle({
+      ...getMockReqOptions(),
+      username: "foo",
+      password: "bar",
+      path: "/",
+    } as any);
+    handler.destroy();
+
+    expect(handler.httpHandlerConfigs().requestTimeout).toEqual(requestTimeout);
+  });
+
+  it("update existing HttpClientConfig", async () => {
+    const server = createMockHttp2Server();
+    server.on("request", (request, response) => {
+      expect(request.url).toBe("http://foo:bar@localhost/");
+      response.statusCode = 200;
+    });
+    const handler = new NodeHttp2Handler({ requestTimeout: 200 });
+
+    const requestTimeout = 300;
+
+    handler.updateHttpClientConfig("requestTimeout", requestTimeout);
+
+    await handler.handle({
+      ...getMockReqOptions(),
+      username: "foo",
+      password: "bar",
+      path: "/",
+    } as any);
+    handler.destroy();
+
+    expect(handler.httpHandlerConfigs().requestTimeout).toEqual(requestTimeout);
+  });
+
+  it("httpHandlerConfigs returns empty object if handle is not called", async () => {
+    const nodeHttpHandler = new NodeHttp2Handler();
+    expect(nodeHttpHandler.httpHandlerConfigs()).toEqual({});
+  });
 });

packages/node-http-handler/src/node-http2-handler.ts

@@ -41,9 +41,9 @@ export interface NodeHttp2HandlerOptions {
   maxConcurrentStreams?: number;
 }
 
-export class NodeHttp2Handler implements HttpHandler {
+export class NodeHttp2Handler implements HttpHandler<NodeHttp2HandlerOptions> {
   private config?: NodeHttp2HandlerOptions;
-  private readonly configProvider: Promise<NodeHttp2HandlerOptions>;
+  private configProvider: Promise<NodeHttp2HandlerOptions>;
 
   public readonly metadata = { handlerProtocol: "h2" };
 
@@ -202,6 +202,20 @@ export class NodeHttp2Handler implements HttpHandler {
     });
   }
 
+  updateHttpClientConfig(key: keyof NodeHttp2HandlerOptions, value: NodeHttp2HandlerOptions[typeof key]): void {
+    this.config = undefined;
+    this.configProvider = this.configProvider.then((resolveConfig) => {
+      return {
+        ...resolveConfig,
+        [key]: value,
+      };
+    });
+  }
+
+  httpHandlerConfigs(): NodeHttp2HandlerOptions {
+    return this.config ?? {};
+  }
+
   /**
    * Destroys a session.
    * @param session The session to destroy.

packages/protocol-http/src/extensions/http.ts

@@ -0,0 +1,42 @@
+import { HttpHandler } from "../httpHandler";
+import { HttpHandlerExtensionConfiguration } from "./httpExtensionConfiguration";
+
+/**
+ * @internal
+ */
+export const getHttpHandlerConfiguration = <HandlerConfig extends object = Record<string, unknown>>(
+  runtimeConfig: Partial<{ httpHandler: HttpHandler<HandlerConfig> }>
+) => {
+  let httpHandler = runtimeConfig.httpHandler!;
+  const httpHandlerConfigs: HandlerConfig = httpHandler.httpHandlerConfigs();
+  return {
+    setHttpHandler(handler: HttpHandler<HandlerConfig>): void {
+      httpHandler = handler;
+    },
+    httpHandler(): HttpHandler<HandlerConfig> {
+      return httpHandler;
+    },
+    updateHttpClientConfig(key: keyof HandlerConfig, value: HandlerConfig[typeof key]): void {
+      httpHandlerConfigs[key] = value;
+    },
+    httpHandlerConfigs(): HandlerConfig {
+      return httpHandlerConfigs;
+    },
+  };
+};
+
+/**
+ * @internal
+ */
+export const resolveHttpHandlerRuntimeConfig = <HandlerConfig extends object = Record<string, unknown>>(
+  httpHandlerExtensionConfiguration: HttpHandlerExtensionConfiguration<HandlerConfig>
+) => {
+  const requestHandler = httpHandlerExtensionConfiguration.httpHandler();
+  const handlerConfig = httpHandlerExtensionConfiguration.httpHandlerConfigs();
+  for (const key in handlerConfig) {
+    requestHandler.updateHttpClientConfig(key, handlerConfig[key]);
+  }
+  return {
+    requestHandler,
+  };
+};

packages/protocol-http/src/extensions/httpExtensionConfiguration.ts

@@ -0,0 +1,42 @@
+import { HttpHandler } from "../httpHandler";
+import {
+  getHttpHandlerConfiguration,
+  resolveHttpHandlerRuntimeConfig as _resolveHttpHandlerRuntimeConfig,
+} from "./http";
+
+/**
+ * @internal
+ */
+export interface HttpHandlerExtensionConfiguration<HandlerConfig extends object = Record<string, unknown>> {
+  setHttpHandler(handler: HttpHandler<HandlerConfig>): void;
+  httpHandler(): HttpHandler<HandlerConfig>;
+  updateHttpClientConfig(key: keyof HandlerConfig, value: HandlerConfig[typeof key]): void;
+  httpHandlerConfigs(): HandlerConfig;
+}
+
+/**
+ * @internal
+ */
+export type HttpHandlerExtensionConfigType = Parameters<typeof getHttpHandlerConfiguration>[0];
+
+/**
+ * @internal
+ *
+ * Helper function to resolve default extension configuration from runtime config
+ */
+export const getHttpHandlerExtensionConfiguration = (runtimeConfig: HttpHandlerExtensionConfigType) => {
+  return {
+    ...getHttpHandlerConfiguration(runtimeConfig),
+  };
+};
+
+/**
+ * @internal
+ *
+ * Helper function to resolve runtime config from default extension configuration
+ */
+export const resolveHttpHandlerRuntimeConfig = (config: HttpHandlerExtensionConfiguration) => {
+  return {
+    ..._resolveHttpHandlerRuntimeConfig(config),
+  };
+};

packages/protocol-http/src/extensions/index.ts

@@ -0,0 +1 @@
+export * from "./httpExtensionConfiguration";

packages/protocol-http/src/httpHandler.ts

@@ -3,4 +3,19 @@ import { HttpHandlerOptions, RequestHandler } from "@smithy/types";
 import { HttpRequest } from "./httpRequest";
 import { HttpResponse } from "./httpResponse";
 
-export type HttpHandler = RequestHandler<HttpRequest, HttpResponse, HttpHandlerOptions>;
+/**
+ * @internal
+ */
+export type HttpHandler<HttpHandlerConfig> = RequestHandler<HttpRequest, HttpResponse, HttpHandlerOptions> & {
+  /**
+   * @internal
+   * @param key
+   * @param value
+   */
+  updateHttpClientConfig(key: keyof HttpHandlerConfig, value: HttpHandlerConfig[typeof key]): void;
+
+  /**
+   * @internal
+   */
+  httpHandlerConfigs: () => HttpHandlerConfig;
+};

packages/protocol-http/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./extensions";
 export * from "./Field";
 export * from "./Fields";
 export * from "./httpHandler";