@graphql-tools/executor-http 1.1.9 → 1.1.10-alpha-f6e086f56c835f084b67e73148dbd7a9dcdd1ec9

package/dist/index.cjs

@@ -0,0 +1,542 @@
+'use strict';
+
+var utils = require('@graphql-tools/utils');
+var fetch = require('@whatwg-node/fetch');
+var valueOrPromise = require('value-or-promise');
+var extractFiles = require('extract-files');
+var graphql = require('graphql');
+var repeater = require('@repeaterjs/repeater');
+var browser = require('meros/browser');
+var node = require('meros/node');
+
+function isGraphQLUpload(upload) {
+  return typeof upload.createReadStream === "function";
+}
+
+function createFormDataFromVariables({
+  query,
+  variables,
+  operationName,
+  extensions
+}, {
+  File: FileCtor = fetch.File,
+  FormData: FormDataCtor = fetch.FormData
+}) {
+  const vars = Object.assign({}, variables);
+  const { clone, files } = extractFiles.extractFiles(
+    vars,
+    "variables",
+    (v) => extractFiles.isExtractableFile(v) || v?.promise || utils.isAsyncIterable(v) || v?.then || typeof v?.arrayBuffer === "function"
+  );
+  if (files.size === 0) {
+    return JSON.stringify(
+      {
+        query,
+        variables,
+        operationName,
+        extensions
+      },
+      null,
+      2
+    );
+  }
+  const map = {};
+  const uploads = [];
+  let currIndex = 0;
+  for (const [file, curr] of files) {
+    map[currIndex] = curr;
+    uploads[currIndex] = file;
+    currIndex++;
+  }
+  const form = new FormDataCtor();
+  form.append(
+    "operations",
+    JSON.stringify({
+      query,
+      variables: clone,
+      operationName,
+      extensions
+    })
+  );
+  form.append("map", JSON.stringify(map, null, 2));
+  function handleUpload(upload, i) {
+    const indexStr = i.toString();
+    if (upload != null) {
+      const filename = upload.filename || upload.name || upload.path || `blob-${indexStr}`;
+      if (utils.isPromise(upload)) {
+        return upload.then(
+          (resolvedUpload) => handleUpload(resolvedUpload, i)
+        );
+      } else if (isBlob(upload)) {
+        form.append(indexStr, upload, filename);
+      } else if (isGraphQLUpload(upload)) {
+        const stream = upload.createReadStream();
+        const chunks = [];
+        return Promise.resolve().then(async () => {
+          for await (const chunk of stream) {
+            if (chunk) {
+              chunks.push(...chunk);
+            }
+          }
+          const blobPart = new Uint8Array(chunks);
+          form.append(
+            indexStr,
+            new FileCtor([blobPart], filename, { type: upload.mimetype }),
+            filename
+          );
+        });
+      } else {
+        form.append(indexStr, new FileCtor([upload], filename), filename);
+      }
+    }
+  }
+  return valueOrPromise.ValueOrPromise.all(
+    uploads.map(
+      (upload, i) => new valueOrPromise.ValueOrPromise(() => handleUpload(upload, i))
+    )
+  ).then(() => form).resolve();
+}
+function isBlob(obj) {
+  return typeof obj.arrayBuffer === "function";
+}
+
+const printCache = /* @__PURE__ */ new WeakMap();
+function defaultPrintFn(document) {
+  let printed = printCache.get(document);
+  if (!printed) {
+    printed = graphql.stripIgnoredCharacters(graphql.print(document));
+    printCache.set(document, printed);
+  }
+  return printed;
+}
+
+const DELIM = "\n\n";
+function isReadableStream(value) {
+  return value && typeof value.getReader === "function";
+}
+function handleEventStreamResponse(response) {
+  const body = response.body;
+  if (!isReadableStream(body)) {
+    throw new Error(
+      "Response body is expected to be a readable stream but got; " + utils.inspect(body)
+    );
+  }
+  return new repeater.Repeater((push, stop) => {
+    const decoder = new fetch.TextDecoder();
+    const reader = body.getReader();
+    reader.closed.then(stop).catch(stop);
+    stop.finally(() => reader.cancel());
+    let currChunk = "";
+    async function pump() {
+      const { done, value: chunk } = await reader.read();
+      if (done) {
+        return stop();
+      }
+      currChunk += typeof chunk === "string" ? chunk : decoder.decode(chunk);
+      for (; ; ) {
+        const delimIndex = currChunk.indexOf(DELIM);
+        if (delimIndex === -1) {
+          break;
+        }
+        const msg = currChunk.slice(0, delimIndex);
+        currChunk = currChunk.slice(delimIndex + DELIM.length);
+        const dataStr = msg.split("data:")[1]?.trim();
+        if (dataStr) {
+          const data = JSON.parse(dataStr);
+          await push(data.payload || data);
+        }
+        const event = msg.split("event:")[1]?.trim();
+        if (event === "complete") {
+          return stop();
+        }
+      }
+      return pump();
+    }
+    return pump();
+  });
+}
+
+function isIncomingMessage(body) {
+  return body != null && typeof body === "object" && "pipe" in body;
+}
+async function handleMultipartMixedResponse(response) {
+  const body = response.body;
+  const contentType = response.headers.get("content-type") || "";
+  let asyncIterator;
+  if (isIncomingMessage(body)) {
+    body.headers = {
+      "content-type": contentType
+    };
+    const result = await node.meros(body);
+    if ("next" in result) {
+      asyncIterator = result;
+    }
+  } else {
+    const result = await browser.meros(response);
+    if ("next" in result) {
+      asyncIterator = result;
+    }
+  }
+  const executionResult = {};
+  if (asyncIterator == null) {
+    return executionResult;
+  }
+  const resultStream = utils.mapAsyncIterator(asyncIterator, (part) => {
+    if (part.json) {
+      const incrementalResult = part.body;
+      utils.mergeIncrementalResult({
+        incrementalResult,
+        executionResult
+      });
+    }
+    return executionResult;
+  });
+  return resultStream;
+}
+
+const isLiveQueryOperationDefinitionNode = utils.memoize1(
+  function isLiveQueryOperationDefinitionNode2(node) {
+    return node.operation === "query" && node.directives?.some((directive) => directive.name.value === "live");
+  }
+);
+
+function prepareGETUrl({
+  baseUrl = "",
+  query,
+  variables,
+  operationName,
+  extensions
+}) {
+  const dummyHostname = "https://dummyhostname.com";
+  const validUrl = baseUrl.startsWith("http") ? baseUrl : baseUrl?.startsWith("/") ? `${dummyHostname}${baseUrl}` : `${dummyHostname}/${baseUrl}`;
+  const urlObj = new URL(validUrl);
+  urlObj.searchParams.set("query", graphql.stripIgnoredCharacters(query));
+  if (variables && Object.keys(variables).length > 0) {
+    urlObj.searchParams.set("variables", JSON.stringify(variables));
+  }
+  if (operationName) {
+    urlObj.searchParams.set("operationName", operationName);
+  }
+  if (extensions) {
+    urlObj.searchParams.set("extensions", JSON.stringify(extensions));
+  }
+  const finalUrl = urlObj.toString().replace(dummyHostname, "");
+  return finalUrl;
+}
+
+function buildHTTPExecutor(options) {
+  const printFn = options?.print ?? defaultPrintFn;
+  let disposeCtrl;
+  const baseExecutor = (request) => {
+    if (disposeCtrl?.signal.aborted) {
+      return createResultForAbort(disposeCtrl.signal);
+    }
+    const fetchFn = request.extensions?.fetch ?? options?.fetch ?? fetch.fetch;
+    let method = request.extensions?.method || options?.method;
+    const operationAst = utils.getOperationASTFromRequest(request);
+    const operationType = operationAst.operation;
+    if ((options?.useGETForQueries || request.extensions?.useGETForQueries) && operationType === "query") {
+      method = "GET";
+    }
+    let accept = "application/graphql-response+json, application/json, multipart/mixed";
+    if (operationType === "subscription" || isLiveQueryOperationDefinitionNode(operationAst)) {
+      method ||= "GET";
+      accept = "text/event-stream";
+    } else {
+      method ||= "POST";
+    }
+    const endpoint = request.extensions?.endpoint || options?.endpoint || "/graphql";
+    const headers = { accept };
+    if (options?.headers) {
+      Object.assign(
+        headers,
+        typeof options?.headers === "function" ? options.headers(request) : options?.headers
+      );
+    }
+    if (request.extensions?.headers) {
+      const { headers: headersFromExtensions, ...restExtensions } = request.extensions;
+      Object.assign(headers, headersFromExtensions);
+      request.extensions = restExtensions;
+    }
+    const query = printFn(request.document);
+    let signal = disposeCtrl?.signal;
+    let clearTimeoutFn = () => {
+    };
+    if (options?.timeout) {
+      const timeoutCtrl = new AbortController();
+      signal = timeoutCtrl.signal;
+      disposeCtrl?.signal.addEventListener("abort", clearTimeoutFn);
+      const timeoutId = setTimeout(() => {
+        if (!timeoutCtrl.signal.aborted) {
+          timeoutCtrl.abort("timeout");
+        }
+        disposeCtrl?.signal.removeEventListener("abort", clearTimeoutFn);
+      }, options.timeout);
+      clearTimeoutFn = () => {
+        clearTimeout(timeoutId);
+      };
+    }
+    const upstreamErrorExtensions = {
+      request: {
+        method
+      },
+      response: {}
+    };
+    return new valueOrPromise.ValueOrPromise(() => {
+      switch (method) {
+        case "GET": {
+          const finalUrl = prepareGETUrl({
+            baseUrl: endpoint,
+            query,
+            variables: request.variables,
+            operationName: request.operationName,
+            extensions: request.extensions
+          });
+          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": {
+          const body = {
+            query,
+            variables: request.variables,
+            operationName: request.operationName,
+            extensions: request.extensions
+          };
+          upstreamErrorExtensions.request.body = body;
+          return new valueOrPromise.ValueOrPromise(
+            () => createFormDataFromVariables(body, {
+              File: options?.File,
+              FormData: options?.FormData
+            })
+          ).then((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
+            );
+          }).resolve();
+        }
+      }
+    }).then((fetchResult) => {
+      upstreamErrorExtensions.response.status = fetchResult.status;
+      upstreamErrorExtensions.response.statusText = fetchResult.statusText;
+      Object.defineProperty(upstreamErrorExtensions.response, "headers", {
+        get() {
+          return Object.fromEntries(fetchResult.headers.entries());
+        }
+      });
+      clearTimeoutFn();
+      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);
+      } else if (contentType?.includes("multipart/mixed")) {
+        return handleMultipartMixedResponse(fetchResult);
+      }
+      return fetchResult.text();
+    }).then((result) => {
+      if (typeof result === "string") {
+        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)) {
+              return {
+                errors: [
+                  utils.createGraphQLError(
+                    'Unexpected empty "data" and "errors" fields in result: ' + result,
+                    {
+                      extensions: upstreamErrorExtensions
+                    }
+                  )
+                ]
+              };
+            }
+            if (Array.isArray(parsedResult.errors)) {
+              return {
+                ...parsedResult,
+                errors: parsedResult.errors.map(
+                  ({
+                    message,
+                    ...options2
+                  }) => utils.createGraphQLError(message, {
+                    ...options2,
+                    extensions: {
+                      code: "DOWNSTREAM_SERVICE_ERROR",
+                      ...options2.extensions || {}
+                    }
+                  })
+                )
+              };
+            }
+            return parsedResult;
+          } catch (e) {
+            return {
+              errors: [
+                utils.createGraphQLError(
+                  `Unexpected response: ${JSON.stringify(result)}`,
+                  {
+                    extensions: upstreamErrorExtensions,
+                    originalError: e
+                  }
+                )
+              ]
+            };
+          }
+        }
+      } else {
+        return result;
+      }
+    }).catch((e) => {
+      if (e.name === "AggregateError") {
+        return {
+          errors: e.errors.map(
+            (e2) => coerceFetchError(e2, {
+              signal,
+              endpoint,
+              upstreamErrorExtensions
+            })
+          )
+        };
+      }
+      return {
+        errors: [
+          coerceFetchError(e, {
+            signal,
+            endpoint,
+            upstreamErrorExtensions
+          })
+        ]
+      };
+    }).resolve();
+  };
+  let executor = baseExecutor;
+  if (options?.retry != null) {
+    executor = function retryExecutor(request) {
+      let result;
+      let attempt = 0;
+      function retryAttempt() {
+        if (disposeCtrl?.signal.aborted) {
+          return createResultForAbort(disposeCtrl.signal);
+        }
+        attempt++;
+        if (attempt > options.retry) {
+          if (result != null) {
+            return result;
+          }
+          return {
+            errors: [utils.createGraphQLError("No response returned from fetch")]
+          };
+        }
+        return new valueOrPromise.ValueOrPromise(() => baseExecutor(request)).then((res) => {
+          result = res;
+          if (result?.errors?.length) {
+            return retryAttempt();
+          }
+          return result;
+        }).resolve();
+      }
+      return retryAttempt();
+    };
+  }
+  if (!options?.disposable) {
+    disposeCtrl = void 0;
+    return executor;
+  }
+  disposeCtrl = new AbortController();
+  Object.defineProperties(executor, {
+    [Symbol.dispose]: {
+      get() {
+        return function dispose() {
+          return disposeCtrl.abort(createAbortErrorReason());
+        };
+      }
+    },
+    [Symbol.asyncDispose]: {
+      get() {
+        return function asyncDispose() {
+          return disposeCtrl.abort(createAbortErrorReason());
+        };
+      }
+    }
+  });
+  return executor;
+}
+function coerceFetchError(e, {
+  signal,
+  endpoint,
+  upstreamErrorExtensions
+}) {
+  if (typeof e === "string") {
+    return utils.createGraphQLError(e, {
+      extensions: upstreamErrorExtensions
+    });
+  } else if (e.name === "GraphQLError") {
+    return e;
+  } else if (e.name === "TypeError" && e.message === "fetch failed") {
+    return utils.createGraphQLError(`fetch failed to ${endpoint}`, {
+      extensions: upstreamErrorExtensions,
+      originalError: e
+    });
+  } else if (e.name === "AbortError" && signal?.reason) {
+    return createGraphQLErrorForAbort(signal, {
+      extensions: upstreamErrorExtensions
+    });
+  } else if (e.message) {
+    return utils.createGraphQLError(e.message, {
+      extensions: upstreamErrorExtensions,
+      originalError: e
+    });
+  } else {
+    return utils.createGraphQLError("Unknown error", {
+      extensions: upstreamErrorExtensions,
+      originalError: e
+    });
+  }
+}
+function createAbortErrorReason() {
+  return new Error("Executor was disposed.");
+}
+function createGraphQLErrorForAbort(signal, extensions) {
+  return utils.createGraphQLError(
+    "The operation was aborted. reason: " + signal.reason,
+    {
+      extensions
+    }
+  );
+}
+function createResultForAbort(signal, extensions) {
+  return {
+    errors: [createGraphQLErrorForAbort(signal, extensions)]
+  };
+}
+
+exports.buildHTTPExecutor = buildHTTPExecutor;
+exports.isLiveQueryOperationDefinitionNode = isLiveQueryOperationDefinitionNode;

package/{typings → dist}/index.d.cts

@@ -1,17 +1,19 @@
-import { DocumentNode, GraphQLResolveInfo } from 'graphql';
-import { AsyncExecutor, DisposableAsyncExecutor, DisposableSyncExecutor, ExecutionRequest, SyncExecutor } from '@graphql-tools/utils';
-import { isLiveQueryOperationDefinitionNode } from './isLiveQueryOperationDefinitionNode.cjs';
-export type SyncFetchFn = (url: string, init?: RequestInit, context?: any, info?: GraphQLResolveInfo) => SyncResponse;
-export type SyncResponse = Omit<Response, 'json' | 'text'> & {
+import { ExecutionRequest, DisposableSyncExecutor, SyncExecutor, DisposableAsyncExecutor, AsyncExecutor } from '@graphql-tools/utils';
+import { OperationDefinitionNode, GraphQLResolveInfo, DocumentNode } from 'graphql';
+
+declare const isLiveQueryOperationDefinitionNode: (node: OperationDefinitionNode) => boolean | undefined;
+
+type SyncFetchFn = (url: string, init?: RequestInit, context?: any, info?: GraphQLResolveInfo) => SyncResponse;
+type SyncResponse = Omit<Response, 'json' | 'text'> & {
     json: () => any;
     text: () => string;
 };
-export type AsyncFetchFn = (url: string, options?: RequestInit, context?: any, info?: GraphQLResolveInfo) => Promise<Response> | Response;
-export type RegularFetchFn = (url: string) => Promise<Response> | Response;
-export type FetchFn = AsyncFetchFn | SyncFetchFn | RegularFetchFn;
-export type AsyncImportFn = (moduleName: string) => PromiseLike<any>;
-export type SyncImportFn = (moduleName: string) => any;
-export interface HTTPExecutorOptions {
+type AsyncFetchFn = (url: string, options?: RequestInit, context?: any, info?: GraphQLResolveInfo) => Promise<Response> | Response;
+type RegularFetchFn = (url: string) => Promise<Response> | Response;
+type FetchFn = AsyncFetchFn | SyncFetchFn | RegularFetchFn;
+type AsyncImportFn = (moduleName: string) => PromiseLike<any>;
+type SyncImportFn = (moduleName: string) => any;
+interface HTTPExecutorOptions {
     endpoint?: string;
     fetch?: FetchFn;
     /**
@@ -59,45 +61,46 @@ export interface HTTPExecutorOptions {
      */
     disposable?: boolean;
 }
-export type HeadersConfig = Record<string, string>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+type HeadersConfig = Record<string, string>;
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     fetch: SyncFetchFn;
     disposable: true;
 }): DisposableSyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     fetch: SyncFetchFn;
     disposable: false;
 }): SyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'> & {
     fetch: SyncFetchFn;
 }): SyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     fetch: AsyncFetchFn;
     disposable: true;
 }): DisposableAsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     fetch: AsyncFetchFn;
     disposable: false;
 }): AsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'> & {
     fetch: AsyncFetchFn;
 }): AsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     fetch: RegularFetchFn;
     disposable: true;
 }): DisposableAsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     fetch: RegularFetchFn;
     disposable: false;
 }): AsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'> & {
     fetch: RegularFetchFn;
 }): AsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     disposable: true;
 }): DisposableAsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch' | 'disposable'> & {
     disposable: false;
 }): AsyncExecutor<any, HTTPExecutorOptions>;
-export declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'>): AsyncExecutor<any, HTTPExecutorOptions>;
-export { isLiveQueryOperationDefinitionNode };
+declare function buildHTTPExecutor(options?: Omit<HTTPExecutorOptions, 'fetch'>): AsyncExecutor<any, HTTPExecutorOptions>;
+
+export { type AsyncFetchFn, type AsyncImportFn, type FetchFn, type HTTPExecutorOptions, type HeadersConfig, type RegularFetchFn, type SyncFetchFn, type SyncImportFn, type SyncResponse, buildHTTPExecutor, isLiveQueryOperationDefinitionNode };