@graphql-hive/plugin-deduplicate-request/dist/index.cjs

'use strict';

var utils = require('@graphql-mesh/utils');
var promiseHelpers = require('@whatwg-node/promise-helpers');

function useDeduplicateRequest() {
  const reqResMapByContext = /* @__PURE__ */ new WeakMap();
  function getReqResMapByContext(context) {
    let reqResMap = reqResMapByContext.get(context);
    if (!reqResMap) {
      reqResMap = /* @__PURE__ */ new Map();
      reqResMapByContext.set(context, reqResMap);
    }
    return reqResMap;
  }
  const resPropMap = /* @__PURE__ */ new WeakMap();
  return {
    onFetch({ url, options, context, info, fetchFn, setFetchFn, endResponse }) {
      if (context != null) {
        let method = "GET";
        if (options.method) {
          method = options.method;
        }
        if (method === "GET") {
          const reqResMap = getReqResMapByContext(context);
          let dedupCacheKey = url;
          if (options.headers) {
            const headersObj = utils.getHeadersObj(options.headers);
            dedupCacheKey += JSON.stringify(headersObj);
          }
          const dedupRes$ = reqResMap.get(dedupCacheKey);
          if (dedupRes$) {
            endResponse(dedupRes$);
            return;
          }
          setFetchFn(() => {
            let dedupRes$2 = reqResMap.get(dedupCacheKey);
            if (dedupRes$2 == null) {
              dedupRes$2 = promiseHelpers.handleMaybePromise(
                () => fetchFn(url, options, context, info),
                (res) => {
                  if (res.status < 200 || res.status > 299) {
                    reqResMap.delete(dedupCacheKey);
                    return res;
                  }
                  let resPropMapByRes = resPropMap.get(res);
                  if (resPropMapByRes == null) {
                    resPropMapByRes = /* @__PURE__ */ new Map();
                    resPropMap.set(res, resPropMapByRes);
                  }
                  return new Proxy(res, {
                    get(target, prop) {
                      if (typeof target[prop] === "function") {
                        return (...args) => {
                          let resPropResult$ = resPropMapByRes.get(prop);
                          if (resPropResult$ == null) {
                            resPropResult$ = target[prop](...args);
                            resPropMapByRes.set(
                              prop,
                              // @ts-expect-error
                              resPropResult$
                            );
                          }
                          return resPropResult$;
                        };
                      }
                      return target[prop];
                    }
                  });
                }
              );
              reqResMap.set(dedupCacheKey, dedupRes$2);
            }
            return dedupRes$2;
          });
        }
      }
    }
  };
}

exports.useDeduplicateRequest = useDeduplicateRequest;