@graphql-tools/executor-http 2.1.2 → 2.1.3-alpha-ca72727f03d744399b898bc79a032554428dcdb9

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @graphql-tools/executor-http
 
+## 2.1.3-alpha-ca72727f03d744399b898bc79a032554428dcdb9
+### Patch Changes
+
+
+
+- [#1419](https://github.com/graphql-hive/gateway/pull/1419) [`ca72727`](https://github.com/graphql-hive/gateway/commit/ca72727f03d744399b898bc79a032554428dcdb9) Thanks [@ardatan](https://github.com/ardatan)! - Inflight request deduplication
+
 ## 2.1.2
 ### Patch Changes
 

package/dist/index.cjs

@@ -538,6 +538,7 @@ function prepareGETUrl({
   return finalUrl;
 }
 
+const inflightRequests = /* @__PURE__ */ new Map();
 function buildHTTPExecutor(options) {
   const printFn = options?.print ?? executorCommon.defaultPrintFn;
   let disposeCtrl;
@@ -668,157 +669,171 @@ function buildHTTPExecutor(options) {
     }
     return promiseHelpers.handleMaybePromise(
       () => serializeFn(),
-      (body) => promiseHelpers.handleMaybePromise(
-        () => {
-          switch (method) {
-            case "GET": {
-              const finalUrl = prepareGETUrl({
-                baseUrl: endpoint,
-                body
-              });
-              const fetchOptions = {
-                method: "GET",
-                headers,
-                signal: signal$1
-              };
-              if (options?.credentials != null) {
-                fetchOptions.credentials = options.credentials;
-              }
-              upstreamErrorExtensions.request.url = finalUrl;
-              return fetchFn(
-                finalUrl,
-                fetchOptions,
-                request.context,
-                request.info
-              );
-            }
-            case "POST": {
-              upstreamErrorExtensions.request.body = body;
-              return promiseHelpers.handleMaybePromise(
-                () => createFormDataFromVariables(body, {
-                  File: options?.File,
-                  FormData: options?.FormData
-                }),
-                (body2) => {
-                  if (typeof body2 === "string" && !headers["content-type"]) {
-                    upstreamErrorExtensions.request.body = body2;
-                    headers["content-type"] = "application/json";
-                  }
-                  const fetchOptions = {
-                    method: "POST",
-                    body: body2,
-                    headers,
-                    signal: signal$1
-                  };
-                  if (options?.credentials != null) {
-                    fetchOptions.credentials = options.credentials;
-                  }
-                  return fetchFn(
-                    endpoint,
-                    fetchOptions,
-                    request.context,
-                    request.info
-                  );
-                },
-                handleError
-              );
-            }
-          }
-        },
-        (fetchResult) => promiseHelpers.handleMaybePromise(
+      (body) => {
+        const inflightRequestId = `${method}:${endpoint}:${JSON.stringify(body)}:${JSON.stringify(headers)}`;
+        const inflightRequestRes = inflightRequests.get(inflightRequestId);
+        if (inflightRequestRes) {
+          return inflightRequestRes;
+        }
+        const promise = promiseHelpers.handleMaybePromise(
           () => {
-            upstreamErrorExtensions.response ||= {};
-            upstreamErrorExtensions.response.status = fetchResult.status;
-            upstreamErrorExtensions.response.statusText = fetchResult.statusText;
-            Object.defineProperty(
-              upstreamErrorExtensions.response,
-              "headers",
-              {
-                get() {
-                  return Object.fromEntries(fetchResult.headers.entries());
+            switch (method) {
+              case "GET": {
+                const finalUrl = prepareGETUrl({
+                  baseUrl: endpoint,
+                  body
+                });
+                const fetchOptions = {
+                  method: "GET",
+                  headers,
+                  signal: signal$1
+                };
+                if (options?.credentials != null) {
+                  fetchOptions.credentials = options.credentials;
                 }
+                upstreamErrorExtensions.request.url = finalUrl;
+                return fetchFn(
+                  finalUrl,
+                  fetchOptions,
+                  request.context,
+                  request.info
+                );
+              }
+              case "POST": {
+                upstreamErrorExtensions.request.body = body;
+                return promiseHelpers.handleMaybePromise(
+                  () => createFormDataFromVariables(body, {
+                    File: options?.File,
+                    FormData: options?.FormData
+                  }),
+                  (body2) => {
+                    if (typeof body2 === "string" && !headers["content-type"]) {
+                      upstreamErrorExtensions.request.body = body2;
+                      headers["content-type"] = "application/json";
+                    }
+                    const fetchOptions = {
+                      method: "POST",
+                      body: body2,
+                      headers,
+                      signal: signal$1
+                    };
+                    if (options?.credentials != null) {
+                      fetchOptions.credentials = options.credentials;
+                    }
+                    return fetchFn(
+                      endpoint,
+                      fetchOptions,
+                      request.context,
+                      request.info
+                    );
+                  },
+                  handleError
+                );
               }
-            );
-            if (options?.retry != null && !fetchResult.status.toString().startsWith("2")) {
-              throw new Error(
-                fetchResult.statusText || `Upstream HTTP Error: ${fetchResult.status}`
-              );
-            }
-            const contentType = fetchResult.headers.get("content-type");
-            if (contentType?.includes("text/event-stream")) {
-              return handleEventStreamResponse(
-                fetchResult,
-                subscriptionCtrl,
-                signal$1
-              );
-            } else if (contentType?.includes("multipart/mixed")) {
-              return handleMultipartMixedResponse(fetchResult);
             }
-            return fetchResult.text();
           },
-          (result) => {
-            if (typeof result === "string") {
+          (fetchResult) => promiseHelpers.handleMaybePromise(
+            () => {
               upstreamErrorExtensions.response ||= {};
-              upstreamErrorExtensions.response.body = result;
-              if (result) {
-                try {
-                  const parsedResult = JSON.parse(result);
-                  upstreamErrorExtensions.response.body = parsedResult;
-                  if (parsedResult.data == null && (parsedResult.errors == null || parsedResult.errors.length === 0)) {
-                    const message = `Unexpected empty "data" and "errors" fields in result: ${result}`;
+              upstreamErrorExtensions.response.status = fetchResult.status;
+              upstreamErrorExtensions.response.statusText = fetchResult.statusText;
+              Object.defineProperty(
+                upstreamErrorExtensions.response,
+                "headers",
+                {
+                  get() {
+                    return Object.fromEntries(fetchResult.headers.entries());
+                  }
+                }
+              );
+              if (options?.retry != null && !fetchResult.status.toString().startsWith("2")) {
+                throw new Error(
+                  fetchResult.statusText || `Upstream HTTP Error: ${fetchResult.status}`
+                );
+              }
+              const contentType = fetchResult.headers.get("content-type");
+              if (contentType?.includes("text/event-stream")) {
+                return handleEventStreamResponse(
+                  fetchResult,
+                  subscriptionCtrl,
+                  signal$1
+                );
+              } else if (contentType?.includes("multipart/mixed")) {
+                return handleMultipartMixedResponse(fetchResult);
+              }
+              return fetchResult.text();
+            },
+            (result) => {
+              if (typeof result === "string") {
+                upstreamErrorExtensions.response ||= {};
+                upstreamErrorExtensions.response.body = result;
+                if (result) {
+                  try {
+                    const parsedResult = JSON.parse(result);
+                    upstreamErrorExtensions.response.body = parsedResult;
+                    if (parsedResult.data == null && (parsedResult.errors == null || parsedResult.errors.length === 0)) {
+                      const message = `Unexpected empty "data" and "errors" fields in result: ${result}`;
+                      return {
+                        errors: [
+                          utils.createGraphQLError(message, {
+                            originalError: new Error(message),
+                            extensions: upstreamErrorExtensions
+                          })
+                        ]
+                      };
+                    }
+                    if (Array.isArray(parsedResult.errors)) {
+                      return {
+                        ...parsedResult,
+                        errors: parsedResult.errors.map(
+                          ({
+                            message,
+                            ...options2
+                          }) => utils.createGraphQLError(message, options2)
+                        )
+                      };
+                    }
+                    return parsedResult;
+                  } catch (e) {
                     return {
                       errors: [
-                        utils.createGraphQLError(message, {
-                          originalError: new Error(message),
-                          extensions: upstreamErrorExtensions
-                        })
+                        utils.createGraphQLError(
+                          `Unexpected response: ${JSON.stringify(result)}`,
+                          {
+                            extensions: upstreamErrorExtensions,
+                            originalError: e
+                          }
+                        )
                       ]
                     };
                   }
-                  if (Array.isArray(parsedResult.errors)) {
-                    return {
-                      ...parsedResult,
-                      errors: parsedResult.errors.map(
-                        ({
-                          message,
-                          ...options2
-                        }) => utils.createGraphQLError(message, options2)
-                      )
-                    };
-                  }
-                  return parsedResult;
-                } catch (e) {
+                } else {
+                  const message = "No response returned";
                   return {
                     errors: [
-                      utils.createGraphQLError(
-                        `Unexpected response: ${JSON.stringify(result)}`,
-                        {
-                          extensions: upstreamErrorExtensions,
-                          originalError: e
-                        }
-                      )
+                      utils.createGraphQLError(message, {
+                        extensions: upstreamErrorExtensions,
+                        originalError: new Error(message)
+                      })
                     ]
                   };
                 }
               } else {
-                const message = "No response returned";
-                return {
-                  errors: [
-                    utils.createGraphQLError(message, {
-                      extensions: upstreamErrorExtensions,
-                      originalError: new Error(message)
-                    })
-                  ]
-                };
+                return result;
               }
-            } else {
-              return result;
-            }
-          },
+            },
+            handleError
+          ),
           handleError
-        ),
-        handleError
-      ),
+        );
+        inflightRequests.set(inflightRequestId, promise);
+        promiseHelpers.handleMaybePromise(
+          () => promise,
+          () => inflightRequests.delete(inflightRequestId),
+          () => inflightRequests.delete(inflightRequestId)
+        );
+        return promise;
+      },
       handleError
     );
   };

package/dist/index.js

@@ -536,6 +536,7 @@ function prepareGETUrl({
   return finalUrl;
 }
 
+const inflightRequests = /* @__PURE__ */ new Map();
 function buildHTTPExecutor(options) {
   const printFn = options?.print ?? defaultPrintFn;
   let disposeCtrl;
@@ -666,157 +667,171 @@ function buildHTTPExecutor(options) {
     }
     return handleMaybePromise(
       () => serializeFn(),
-      (body) => handleMaybePromise(
-        () => {
-          switch (method) {
-            case "GET": {
-              const finalUrl = prepareGETUrl({
-                baseUrl: endpoint,
-                body
-              });
-              const fetchOptions = {
-                method: "GET",
-                headers,
-                signal
-              };
-              if (options?.credentials != null) {
-                fetchOptions.credentials = options.credentials;
-              }
-              upstreamErrorExtensions.request.url = finalUrl;
-              return fetchFn(
-                finalUrl,
-                fetchOptions,
-                request.context,
-                request.info
-              );
-            }
-            case "POST": {
-              upstreamErrorExtensions.request.body = body;
-              return handleMaybePromise(
-                () => createFormDataFromVariables(body, {
-                  File: options?.File,
-                  FormData: options?.FormData
-                }),
-                (body2) => {
-                  if (typeof body2 === "string" && !headers["content-type"]) {
-                    upstreamErrorExtensions.request.body = body2;
-                    headers["content-type"] = "application/json";
-                  }
-                  const fetchOptions = {
-                    method: "POST",
-                    body: body2,
-                    headers,
-                    signal
-                  };
-                  if (options?.credentials != null) {
-                    fetchOptions.credentials = options.credentials;
-                  }
-                  return fetchFn(
-                    endpoint,
-                    fetchOptions,
-                    request.context,
-                    request.info
-                  );
-                },
-                handleError
-              );
-            }
-          }
-        },
-        (fetchResult) => handleMaybePromise(
+      (body) => {
+        const inflightRequestId = `${method}:${endpoint}:${JSON.stringify(body)}:${JSON.stringify(headers)}`;
+        const inflightRequestRes = inflightRequests.get(inflightRequestId);
+        if (inflightRequestRes) {
+          return inflightRequestRes;
+        }
+        const promise = handleMaybePromise(
           () => {
-            upstreamErrorExtensions.response ||= {};
-            upstreamErrorExtensions.response.status = fetchResult.status;
-            upstreamErrorExtensions.response.statusText = fetchResult.statusText;
-            Object.defineProperty(
-              upstreamErrorExtensions.response,
-              "headers",
-              {
-                get() {
-                  return Object.fromEntries(fetchResult.headers.entries());
+            switch (method) {
+              case "GET": {
+                const finalUrl = prepareGETUrl({
+                  baseUrl: endpoint,
+                  body
+                });
+                const fetchOptions = {
+                  method: "GET",
+                  headers,
+                  signal
+                };
+                if (options?.credentials != null) {
+                  fetchOptions.credentials = options.credentials;
                 }
+                upstreamErrorExtensions.request.url = finalUrl;
+                return fetchFn(
+                  finalUrl,
+                  fetchOptions,
+                  request.context,
+                  request.info
+                );
+              }
+              case "POST": {
+                upstreamErrorExtensions.request.body = body;
+                return handleMaybePromise(
+                  () => createFormDataFromVariables(body, {
+                    File: options?.File,
+                    FormData: options?.FormData
+                  }),
+                  (body2) => {
+                    if (typeof body2 === "string" && !headers["content-type"]) {
+                      upstreamErrorExtensions.request.body = body2;
+                      headers["content-type"] = "application/json";
+                    }
+                    const fetchOptions = {
+                      method: "POST",
+                      body: body2,
+                      headers,
+                      signal
+                    };
+                    if (options?.credentials != null) {
+                      fetchOptions.credentials = options.credentials;
+                    }
+                    return fetchFn(
+                      endpoint,
+                      fetchOptions,
+                      request.context,
+                      request.info
+                    );
+                  },
+                  handleError
+                );
               }
-            );
-            if (options?.retry != null && !fetchResult.status.toString().startsWith("2")) {
-              throw new Error(
-                fetchResult.statusText || `Upstream HTTP Error: ${fetchResult.status}`
-              );
-            }
-            const contentType = fetchResult.headers.get("content-type");
-            if (contentType?.includes("text/event-stream")) {
-              return handleEventStreamResponse(
-                fetchResult,
-                subscriptionCtrl,
-                signal
-              );
-            } else if (contentType?.includes("multipart/mixed")) {
-              return handleMultipartMixedResponse(fetchResult);
             }
-            return fetchResult.text();
           },
-          (result) => {
-            if (typeof result === "string") {
+          (fetchResult) => handleMaybePromise(
+            () => {
               upstreamErrorExtensions.response ||= {};
-              upstreamErrorExtensions.response.body = result;
-              if (result) {
-                try {
-                  const parsedResult = JSON.parse(result);
-                  upstreamErrorExtensions.response.body = parsedResult;
-                  if (parsedResult.data == null && (parsedResult.errors == null || parsedResult.errors.length === 0)) {
-                    const message = `Unexpected empty "data" and "errors" fields in result: ${result}`;
+              upstreamErrorExtensions.response.status = fetchResult.status;
+              upstreamErrorExtensions.response.statusText = fetchResult.statusText;
+              Object.defineProperty(
+                upstreamErrorExtensions.response,
+                "headers",
+                {
+                  get() {
+                    return Object.fromEntries(fetchResult.headers.entries());
+                  }
+                }
+              );
+              if (options?.retry != null && !fetchResult.status.toString().startsWith("2")) {
+                throw new Error(
+                  fetchResult.statusText || `Upstream HTTP Error: ${fetchResult.status}`
+                );
+              }
+              const contentType = fetchResult.headers.get("content-type");
+              if (contentType?.includes("text/event-stream")) {
+                return handleEventStreamResponse(
+                  fetchResult,
+                  subscriptionCtrl,
+                  signal
+                );
+              } else if (contentType?.includes("multipart/mixed")) {
+                return handleMultipartMixedResponse(fetchResult);
+              }
+              return fetchResult.text();
+            },
+            (result) => {
+              if (typeof result === "string") {
+                upstreamErrorExtensions.response ||= {};
+                upstreamErrorExtensions.response.body = result;
+                if (result) {
+                  try {
+                    const parsedResult = JSON.parse(result);
+                    upstreamErrorExtensions.response.body = parsedResult;
+                    if (parsedResult.data == null && (parsedResult.errors == null || parsedResult.errors.length === 0)) {
+                      const message = `Unexpected empty "data" and "errors" fields in result: ${result}`;
+                      return {
+                        errors: [
+                          createGraphQLError(message, {
+                            originalError: new Error(message),
+                            extensions: upstreamErrorExtensions
+                          })
+                        ]
+                      };
+                    }
+                    if (Array.isArray(parsedResult.errors)) {
+                      return {
+                        ...parsedResult,
+                        errors: parsedResult.errors.map(
+                          ({
+                            message,
+                            ...options2
+                          }) => createGraphQLError(message, options2)
+                        )
+                      };
+                    }
+                    return parsedResult;
+                  } catch (e) {
                     return {
                       errors: [
-                        createGraphQLError(message, {
-                          originalError: new Error(message),
-                          extensions: upstreamErrorExtensions
-                        })
+                        createGraphQLError(
+                          `Unexpected response: ${JSON.stringify(result)}`,
+                          {
+                            extensions: upstreamErrorExtensions,
+                            originalError: e
+                          }
+                        )
                       ]
                     };
                   }
-                  if (Array.isArray(parsedResult.errors)) {
-                    return {
-                      ...parsedResult,
-                      errors: parsedResult.errors.map(
-                        ({
-                          message,
-                          ...options2
-                        }) => createGraphQLError(message, options2)
-                      )
-                    };
-                  }
-                  return parsedResult;
-                } catch (e) {
+                } else {
+                  const message = "No response returned";
                   return {
                     errors: [
-                      createGraphQLError(
-                        `Unexpected response: ${JSON.stringify(result)}`,
-                        {
-                          extensions: upstreamErrorExtensions,
-                          originalError: e
-                        }
-                      )
+                      createGraphQLError(message, {
+                        extensions: upstreamErrorExtensions,
+                        originalError: new Error(message)
+                      })
                     ]
                   };
                 }
               } else {
-                const message = "No response returned";
-                return {
-                  errors: [
-                    createGraphQLError(message, {
-                      extensions: upstreamErrorExtensions,
-                      originalError: new Error(message)
-                    })
-                  ]
-                };
+                return result;
               }
-            } else {
-              return result;
-            }
-          },
+            },
+            handleError
+          ),
           handleError
-        ),
-        handleError
-      ),
+        );
+        inflightRequests.set(inflightRequestId, promise);
+        handleMaybePromise(
+          () => promise,
+          () => inflightRequests.delete(inflightRequestId),
+          () => inflightRequests.delete(inflightRequestId)
+        );
+        return promise;
+      },
       handleError
     );
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/executor-http",
-  "version": "2.1.2",
+  "version": "2.1.3-alpha-ca72727f03d744399b898bc79a032554428dcdb9",
   "type": "module",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": {