@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/graphql-yoga/esm/plugins/result-processor/sse.js

@@ -0,0 +1,83 @@
+import { handleMaybePromise, fakePromise } from "../../../../@whatwg-node/promise-helpers/esm/index.js";
+import { getResponseInitByRespectingErrors } from "../../error.js";
+import { jsonStringifyResultWithoutInternals } from "./stringify.js";
+import { isAsyncIterable } from "../../../../@envelop/core/esm/utils.js";
+function getSSEProcessor() {
+  return function processSSEResult(result, fetchAPI) {
+    let pingIntervalMs = 12e3;
+    if (globalThis.process?.env?.["NODE_ENV"] === "test") {
+      pingIntervalMs = 300;
+    }
+    const headersInit = {
+      "Content-Type": "text/event-stream",
+      Connection: "keep-alive",
+      "Cache-Control": "no-cache",
+      "Content-Encoding": "none"
+    };
+    const responseInit = getResponseInitByRespectingErrors(result, headersInit, true);
+    let iterator;
+    let pingInterval;
+    const textEncoder = new fetchAPI.TextEncoder();
+    const readableStream = new fetchAPI.ReadableStream({
+      start(controller) {
+        controller.enqueue(textEncoder.encode(":\n\n"));
+        pingInterval = setInterval(() => {
+          if (!controller.desiredSize) {
+            clearInterval(pingInterval);
+            return;
+          }
+          controller.enqueue(textEncoder.encode(":\n\n"));
+        }, pingIntervalMs);
+        if (isAsyncIterable(result)) {
+          iterator = result[Symbol.asyncIterator]();
+        } else {
+          let finished = false;
+          iterator = {
+            next: () => {
+              if (finished) {
+                return fakePromise({ done: true, value: null });
+              }
+              finished = true;
+              return fakePromise({ done: false, value: result });
+            }
+          };
+        }
+      },
+      pull(controller) {
+        return handleMaybePromise(() => iterator.next(), (result2) => {
+          if (result2.value != null) {
+            controller.enqueue(textEncoder.encode(`event: next
+`));
+            const chunk = jsonStringifyResultWithoutInternals(result2.value);
+            controller.enqueue(textEncoder.encode(`data: ${chunk}
+
+`));
+          }
+          if (result2.done) {
+            controller.enqueue(textEncoder.encode(`event: complete
+`));
+            controller.enqueue(textEncoder.encode(`data:
+
+`));
+            clearInterval(pingInterval);
+            controller.close();
+          }
+        }, (err) => {
+          controller.error(err);
+        });
+      },
+      cancel(e) {
+        clearInterval(pingInterval);
+        if (iterator.return) {
+          return handleMaybePromise(() => iterator.return?.(e), () => {
+          });
+        }
+      }
+    });
+    return new fetchAPI.Response(readableStream, responseInit);
+  };
+}
+export {
+  getSSEProcessor
+};
+//# sourceMappingURL=sse.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/result-processor/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/result-processor/sse.js"],"sourcesContent":["import { isAsyncIterable } from '@envelop/core';\nimport { handleMaybePromise } from '@whatwg-node/promise-helpers';\nimport { fakePromise } from '@whatwg-node/server';\nimport { getResponseInitByRespectingErrors } from '../../error.js';\nimport { jsonStringifyResultWithoutInternals } from './stringify.js';\nexport function getSSEProcessor() {\n    return function processSSEResult(result, fetchAPI) {\n        let pingIntervalMs = 12_000;\n        // for testing the pings, reduce the timeout\n        if (globalThis.process?.env?.['NODE_ENV'] === 'test') {\n            pingIntervalMs = 300;\n        }\n        const headersInit = {\n            'Content-Type': 'text/event-stream',\n            Connection: 'keep-alive',\n            'Cache-Control': 'no-cache',\n            'Content-Encoding': 'none',\n        };\n        const responseInit = getResponseInitByRespectingErrors(result, headersInit, true);\n        let iterator;\n        let pingInterval;\n        const textEncoder = new fetchAPI.TextEncoder();\n        const readableStream = new fetchAPI.ReadableStream({\n            start(controller) {\n                // always start with a ping because some browsers dont accept a header flush\n                // causing the fetch to stall until something is streamed through the response\n                controller.enqueue(textEncoder.encode(':\\n\\n'));\n                // ping client every 12 seconds to keep the connection alive\n                pingInterval = setInterval(() => {\n                    if (!controller.desiredSize) {\n                        clearInterval(pingInterval);\n                        return;\n                    }\n                    controller.enqueue(textEncoder.encode(':\\n\\n'));\n                }, pingIntervalMs);\n                if (isAsyncIterable(result)) {\n                    iterator = result[Symbol.asyncIterator]();\n                }\n                else {\n                    let finished = false;\n                    iterator = {\n                        next: () => {\n                            if (finished) {\n                                return fakePromise({ done: true, value: null });\n                            }\n                            finished = true;\n                            return fakePromise({ done: false, value: result });\n                        },\n                    };\n                }\n            },\n            pull(controller) {\n                return handleMaybePromise(() => iterator.next(), result => {\n                    if (result.value != null) {\n                        controller.enqueue(textEncoder.encode(`event: next\\n`));\n                        const chunk = jsonStringifyResultWithoutInternals(result.value);\n                        controller.enqueue(textEncoder.encode(`data: ${chunk}\\n\\n`));\n                    }\n                    if (result.done) {\n                        controller.enqueue(textEncoder.encode(`event: complete\\n`));\n                        controller.enqueue(textEncoder.encode(`data:\\n\\n`));\n                        clearInterval(pingInterval);\n                        controller.close();\n                    }\n                }, err => {\n                    controller.error(err);\n                });\n            },\n            cancel(e) {\n                clearInterval(pingInterval);\n                if (iterator.return) {\n                    return handleMaybePromise(() => iterator.return?.(e), () => { });\n                }\n            },\n        });\n        return new fetchAPI.Response(readableStream, responseInit);\n    };\n}\n"],"names":["result"],"mappings":";;;;AAKO,SAAS,kBAAkB;AAC9B,SAAO,SAAS,iBAAiB,QAAQ,UAAU;AAC/C,QAAI,iBAAiB;AAErB,QAAI,WAAW,SAAS,MAAM,UAAU,MAAM,QAAQ;AAClD,uBAAiB;AAAA,IACrB;AACA,UAAM,cAAc;AAAA,MAChB,gBAAgB;AAAA,MAChB,YAAY;AAAA,MACZ,iBAAiB;AAAA,MACjB,oBAAoB;AAAA,IAChC;AACQ,UAAM,eAAe,kCAAkC,QAAQ,aAAa,IAAI;AAChF,QAAI;AACJ,QAAI;AACJ,UAAM,cAAc,IAAI,SAAS,YAAW;AAC5C,UAAM,iBAAiB,IAAI,SAAS,eAAe;AAAA,MAC/C,MAAM,YAAY;AAGd,mBAAW,QAAQ,YAAY,OAAO,OAAO,CAAC;AAE9C,uBAAe,YAAY,MAAM;AAC7B,cAAI,CAAC,WAAW,aAAa;AACzB,0BAAc,YAAY;AAC1B;AAAA,UACJ;AACA,qBAAW,QAAQ,YAAY,OAAO,OAAO,CAAC;AAAA,QAClD,GAAG,cAAc;AACjB,YAAI,gBAAgB,MAAM,GAAG;AACzB,qBAAW,OAAO,OAAO,aAAa,EAAC;AAAA,QAC3C,OACK;AACD,cAAI,WAAW;AACf,qBAAW;AAAA,YACP,MAAM,MAAM;AACR,kBAAI,UAAU;AACV,uBAAO,YAAY,EAAE,MAAM,MAAM,OAAO,KAAI,CAAE;AAAA,cAClD;AACA,yBAAW;AACX,qBAAO,YAAY,EAAE,MAAM,OAAO,OAAO,OAAM,CAAE;AAAA,YACrD;AAAA,UACxB;AAAA,QACgB;AAAA,MACJ;AAAA,MACA,KAAK,YAAY;AACb,eAAO,mBAAmB,MAAM,SAAS,KAAI,GAAI,CAAAA,YAAU;AACvD,cAAIA,QAAO,SAAS,MAAM;AACtB,uBAAW,QAAQ,YAAY,OAAO;AAAA,CAAe,CAAC;AACtD,kBAAM,QAAQ,oCAAoCA,QAAO,KAAK;AAC9D,uBAAW,QAAQ,YAAY,OAAO,SAAS,KAAK;AAAA;AAAA,CAAM,CAAC;AAAA,UAC/D;AACA,cAAIA,QAAO,MAAM;AACb,uBAAW,QAAQ,YAAY,OAAO;AAAA,CAAmB,CAAC;AAC1D,uBAAW,QAAQ,YAAY,OAAO;AAAA;AAAA,CAAW,CAAC;AAClD,0BAAc,YAAY;AAC1B,uBAAW,MAAK;AAAA,UACpB;AAAA,QACJ,GAAG,SAAO;AACN,qBAAW,MAAM,GAAG;AAAA,QACxB,CAAC;AAAA,MACL;AAAA,MACA,OAAO,GAAG;AACN,sBAAc,YAAY;AAC1B,YAAI,SAAS,QAAQ;AACjB,iBAAO,mBAAmB,MAAM,SAAS,SAAS,CAAC,GAAG,MAAM;AAAA,UAAE,CAAC;AAAA,QACnE;AAAA,MACJ;AAAA,IACZ,CAAS;AACD,WAAO,IAAI,SAAS,SAAS,gBAAgB,YAAY;AAAA,EAC7D;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/result-processor/stringify.js

@@ -0,0 +1,47 @@
+import { isGraphQLError } from "../../error.js";
+import { createGraphQLError, getSchemaCoordinate } from "../../../../@graphql-tools/utils/esm/errors.js";
+function jsonStringifyResultWithoutInternals(result) {
+  if (Array.isArray(result)) {
+    return `[${result.map((r) => {
+      const sanitizedResult2 = omitInternalsFromResultErrors(r);
+      const stringifier2 = r.stringify || JSON.stringify;
+      return stringifier2(sanitizedResult2);
+    }).join(",")}]`;
+  }
+  const sanitizedResult = omitInternalsFromResultErrors(result);
+  const stringifier = result.stringify || JSON.stringify;
+  return stringifier(sanitizedResult);
+}
+function omitInternalsFromResultErrors(result) {
+  if (result.errors?.length || result.extensions?.http) {
+    const newResult = { ...result };
+    newResult.errors &&= newResult.errors.map(omitInternalsFromError);
+    if (newResult.extensions) {
+      const { http, ...extensions } = result.extensions;
+      newResult.extensions = Object.keys(extensions).length ? extensions : void 0;
+    }
+    return newResult;
+  }
+  return result;
+}
+function omitInternalsFromError(err) {
+  if (isGraphQLError(err)) {
+    const serializedError = "toJSON" in err && typeof err.toJSON === "function" ? err.toJSON() : Object(err);
+    const { http, unexpected, ...extensions } = serializedError.extensions || {};
+    return createGraphQLError(err.message, {
+      nodes: err.nodes,
+      source: err.source,
+      positions: err.positions,
+      path: err.path,
+      originalError: omitInternalsFromError(err.originalError || void 0),
+      extensions: Object.keys(extensions).length ? extensions : void 0,
+      coordinate: getSchemaCoordinate(err)
+    });
+  }
+  return err;
+}
+export {
+  jsonStringifyResultWithoutInternals,
+  omitInternalsFromResultErrors
+};
+//# sourceMappingURL=stringify.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/result-processor/stringify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/result-processor/stringify.js"],"sourcesContent":["import { createGraphQLError, getSchemaCoordinate } from '@graphql-tools/utils';\nimport { isGraphQLError } from '../../error.js';\n// JSON stringifier that adjusts the result error extensions while serialising\nexport function jsonStringifyResultWithoutInternals(result) {\n    if (Array.isArray(result)) {\n        return `[${result\n            .map(r => {\n            const sanitizedResult = omitInternalsFromResultErrors(r);\n            const stringifier = r.stringify || JSON.stringify;\n            return stringifier(sanitizedResult);\n        })\n            .join(',')}]`;\n    }\n    const sanitizedResult = omitInternalsFromResultErrors(result);\n    const stringifier = result.stringify || JSON.stringify;\n    return stringifier(sanitizedResult);\n}\nexport function omitInternalsFromResultErrors(result) {\n    if (result.errors?.length || result.extensions?.http) {\n        const newResult = { ...result };\n        newResult.errors &&= newResult.errors.map(omitInternalsFromError);\n        if (newResult.extensions) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars -- TS should check for unused vars instead\n            const { http, ...extensions } = result.extensions;\n            newResult.extensions = Object.keys(extensions).length ? extensions : undefined;\n        }\n        return newResult;\n    }\n    return result;\n}\nfunction omitInternalsFromError(err) {\n    if (isGraphQLError(err)) {\n        const serializedError = 'toJSON' in err && typeof err.toJSON === 'function' ? err.toJSON() : Object(err);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars -- TS should check for unused vars instead\n        const { http, unexpected, ...extensions } = serializedError.extensions || {};\n        return createGraphQLError(err.message, {\n            nodes: err.nodes,\n            source: err.source,\n            positions: err.positions,\n            path: err.path,\n            originalError: omitInternalsFromError(err.originalError || undefined),\n            extensions: Object.keys(extensions).length ? extensions : undefined,\n            coordinate: getSchemaCoordinate(err),\n        });\n    }\n    return err;\n}\n"],"names":["sanitizedResult","stringifier"],"mappings":";;AAGO,SAAS,oCAAoC,QAAQ;AACxD,MAAI,MAAM,QAAQ,MAAM,GAAG;AACvB,WAAO,IAAI,OACN,IAAI,OAAK;AACV,YAAMA,mBAAkB,8BAA8B,CAAC;AACvD,YAAMC,eAAc,EAAE,aAAa,KAAK;AACxC,aAAOA,aAAYD,gBAAe;AAAA,IACtC,CAAC,EACI,KAAK,GAAG,CAAC;AAAA,EAClB;AACA,QAAM,kBAAkB,8BAA8B,MAAM;AAC5D,QAAM,cAAc,OAAO,aAAa,KAAK;AAC7C,SAAO,YAAY,eAAe;AACtC;AACO,SAAS,8BAA8B,QAAQ;AAClD,MAAI,OAAO,QAAQ,UAAU,OAAO,YAAY,MAAM;AAClD,UAAM,YAAY,EAAE,GAAG,OAAM;AAC7B,cAAU,WAAW,UAAU,OAAO,IAAI,sBAAsB;AAChE,QAAI,UAAU,YAAY;AAEtB,YAAM,EAAE,MAAM,GAAG,WAAU,IAAK,OAAO;AACvC,gBAAU,aAAa,OAAO,KAAK,UAAU,EAAE,SAAS,aAAa;AAAA,IACzE;AACA,WAAO;AAAA,EACX;AACA,SAAO;AACX;AACA,SAAS,uBAAuB,KAAK;AACjC,MAAI,eAAe,GAAG,GAAG;AACrB,UAAM,kBAAkB,YAAY,OAAO,OAAO,IAAI,WAAW,aAAa,IAAI,WAAW,OAAO,GAAG;AAEvG,UAAM,EAAE,MAAM,YAAY,GAAG,WAAU,IAAK,gBAAgB,cAAc,CAAA;AAC1E,WAAO,mBAAmB,IAAI,SAAS;AAAA,MACnC,OAAO,IAAI;AAAA,MACX,QAAQ,IAAI;AAAA,MACZ,WAAW,IAAI;AAAA,MACf,MAAM,IAAI;AAAA,MACV,eAAe,uBAAuB,IAAI,iBAAiB,MAAS;AAAA,MACpE,YAAY,OAAO,KAAK,UAAU,EAAE,SAAS,aAAa;AAAA,MAC1D,YAAY,oBAAoB,GAAG;AAAA,IAC/C,CAAS;AAAA,EACL;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/use-graphiql.js

@@ -0,0 +1,55 @@
+import { handleMaybePromise } from "../../../@whatwg-node/promise-helpers/esm/index.js";
+import graphiqlHTML from "../graphiql-html.js";
+function shouldRenderGraphiQL({ headers, method }) {
+  return method === "GET" && !!headers?.get("accept")?.includes("text/html");
+}
+const renderGraphiQL = (opts) => graphiqlHTML.replace("__TITLE__", opts?.title || "Yoga GraphiQL").replace("__OPTS__", JSON.stringify(opts ?? {}));
+function useGraphiQL(config) {
+  const logger = config.logger ?? console;
+  let graphiqlOptionsFactory;
+  if (typeof config?.options === "function") {
+    graphiqlOptionsFactory = config?.options;
+  } else if (typeof config?.options === "object") {
+    graphiqlOptionsFactory = () => config?.options;
+  } else if (config?.options === false) {
+    graphiqlOptionsFactory = () => false;
+  } else {
+    graphiqlOptionsFactory = () => ({});
+  }
+  const renderer = config?.render ?? renderGraphiQL;
+  let urlPattern;
+  const getUrlPattern = ({ URLPattern }) => {
+    urlPattern ||= new URLPattern({
+      pathname: config.graphqlEndpoint
+    });
+    return urlPattern;
+  };
+  return {
+    onRequest({ request, serverContext, fetchAPI, endResponse, url }) {
+      if (shouldRenderGraphiQL(request) && (request.url.endsWith(config.graphqlEndpoint) || request.url.endsWith(`${config.graphqlEndpoint}/`) || url.pathname === config.graphqlEndpoint || url.pathname === `${config.graphqlEndpoint}/` || getUrlPattern(fetchAPI).test(url))) {
+        logger.debug(`Rendering GraphiQL`);
+        return handleMaybePromise(() => graphiqlOptionsFactory(request, serverContext), (graphiqlOptions) => {
+          if (graphiqlOptions) {
+            return handleMaybePromise(() => renderer({
+              ...graphiqlOptions === true ? {} : graphiqlOptions
+            }), (graphiqlBody) => {
+              const response = new fetchAPI.Response(graphiqlBody, {
+                headers: {
+                  "Content-Type": "text/html"
+                },
+                status: 200
+              });
+              endResponse(response);
+            });
+          }
+        });
+      }
+    }
+  };
+}
+export {
+  renderGraphiQL,
+  shouldRenderGraphiQL,
+  useGraphiQL
+};
+//# sourceMappingURL=use-graphiql.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/use-graphiql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-graphiql.js","sources":["../../../../../node_modules/graphql-yoga/esm/plugins/use-graphiql.js"],"sourcesContent":["import { handleMaybePromise } from '@whatwg-node/promise-helpers';\nimport graphiqlHTML from '../graphiql-html.js';\nexport function shouldRenderGraphiQL({ headers, method }) {\n    return method === 'GET' && !!headers?.get('accept')?.includes('text/html');\n}\nexport const renderGraphiQL = (opts) => graphiqlHTML\n    .replace('__TITLE__', opts?.title || 'Yoga GraphiQL')\n    .replace('__OPTS__', JSON.stringify(opts ?? {}));\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useGraphiQL(config) {\n    const logger = config.logger ?? console;\n    let graphiqlOptionsFactory;\n    if (typeof config?.options === 'function') {\n        graphiqlOptionsFactory = config?.options;\n    }\n    else if (typeof config?.options === 'object') {\n        graphiqlOptionsFactory = () => config?.options;\n    }\n    else if (config?.options === false) {\n        graphiqlOptionsFactory = () => false;\n    }\n    else {\n        graphiqlOptionsFactory = () => ({});\n    }\n    const renderer = config?.render ?? renderGraphiQL;\n    let urlPattern;\n    const getUrlPattern = ({ URLPattern }) => {\n        urlPattern ||= new URLPattern({\n            pathname: config.graphqlEndpoint,\n        });\n        return urlPattern;\n    };\n    return {\n        onRequest({ request, serverContext, fetchAPI, endResponse, url }) {\n            if (shouldRenderGraphiQL(request) &&\n                (request.url.endsWith(config.graphqlEndpoint) ||\n                    request.url.endsWith(`${config.graphqlEndpoint}/`) ||\n                    url.pathname === config.graphqlEndpoint ||\n                    url.pathname === `${config.graphqlEndpoint}/` ||\n                    getUrlPattern(fetchAPI).test(url))) {\n                logger.debug(`Rendering GraphiQL`);\n                return handleMaybePromise(() => graphiqlOptionsFactory(request, serverContext), graphiqlOptions => {\n                    if (graphiqlOptions) {\n                        return handleMaybePromise(() => renderer({\n                            ...(graphiqlOptions === true ? {} : graphiqlOptions),\n                        }), graphiqlBody => {\n                            const response = new fetchAPI.Response(graphiqlBody, {\n                                headers: {\n                                    'Content-Type': 'text/html',\n                                },\n                                status: 200,\n                            });\n                            endResponse(response);\n                        });\n                    }\n                });\n            }\n        },\n    };\n}\n"],"names":[],"mappings":";;AAEO,SAAS,qBAAqB,EAAE,SAAS,UAAU;AACtD,SAAO,WAAW,SAAS,CAAC,CAAC,SAAS,IAAI,QAAQ,GAAG,SAAS,WAAW;AAC7E;AACY,MAAC,iBAAiB,CAAC,SAAS,aACnC,QAAQ,aAAa,MAAM,SAAS,eAAe,EACnD,QAAQ,YAAY,KAAK,UAAU,QAAQ,CAAA,CAAE,CAAC;AAE5C,SAAS,YAAY,QAAQ;AAChC,QAAM,SAAS,OAAO,UAAU;AAChC,MAAI;AACJ,MAAI,OAAO,QAAQ,YAAY,YAAY;AACvC,6BAAyB,QAAQ;AAAA,EACrC,WACS,OAAO,QAAQ,YAAY,UAAU;AAC1C,6BAAyB,MAAM,QAAQ;AAAA,EAC3C,WACS,QAAQ,YAAY,OAAO;AAChC,6BAAyB,MAAM;AAAA,EACnC,OACK;AACD,6BAAyB,OAAO,CAAA;AAAA,EACpC;AACA,QAAM,WAAW,QAAQ,UAAU;AACnC,MAAI;AACJ,QAAM,gBAAgB,CAAC,EAAE,iBAAiB;AACtC,mBAAe,IAAI,WAAW;AAAA,MAC1B,UAAU,OAAO;AAAA,IAC7B,CAAS;AACD,WAAO;AAAA,EACX;AACA,SAAO;AAAA,IACH,UAAU,EAAE,SAAS,eAAe,UAAU,aAAa,OAAO;AAC9D,UAAI,qBAAqB,OAAO,MAC3B,QAAQ,IAAI,SAAS,OAAO,eAAe,KACxC,QAAQ,IAAI,SAAS,GAAG,OAAO,eAAe,GAAG,KACjD,IAAI,aAAa,OAAO,mBACxB,IAAI,aAAa,GAAG,OAAO,eAAe,OAC1C,cAAc,QAAQ,EAAE,KAAK,GAAG,IAAI;AACxC,eAAO,MAAM,oBAAoB;AACjC,eAAO,mBAAmB,MAAM,uBAAuB,SAAS,aAAa,GAAG,qBAAmB;AAC/F,cAAI,iBAAiB;AACjB,mBAAO,mBAAmB,MAAM,SAAS;AAAA,cACrC,GAAI,oBAAoB,OAAO,CAAA,IAAK;AAAA,YAChE,CAAyB,GAAG,kBAAgB;AAChB,oBAAM,WAAW,IAAI,SAAS,SAAS,cAAc;AAAA,gBACjD,SAAS;AAAA,kBACL,gBAAgB;AAAA,gBACpD;AAAA,gBACgC,QAAQ;AAAA,cACxC,CAA6B;AACD,0BAAY,QAAQ;AAAA,YACxB,CAAC;AAAA,UACL;AAAA,QACJ,CAAC;AAAA,MACL;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/use-health-check.js

@@ -0,0 +1,20 @@
+function useHealthCheck({ id = Date.now().toString(), logger = console, endpoint = "/health" } = {}) {
+  return {
+    onRequest({ endResponse, fetchAPI, request }) {
+      if (request.url.endsWith(endpoint)) {
+        logger.debug("Responding Health Check");
+        const response = new fetchAPI.Response(null, {
+          status: 200,
+          headers: {
+            "x-yoga-id": id
+          }
+        });
+        endResponse(response);
+      }
+    }
+  };
+}
+export {
+  useHealthCheck
+};
+//# sourceMappingURL=use-health-check.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/use-health-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-health-check.js","sources":["../../../../../node_modules/graphql-yoga/esm/plugins/use-health-check.js"],"sourcesContent":["export function useHealthCheck({ id = Date.now().toString(), logger = console, endpoint = '/health', } = {}) {\n    return {\n        onRequest({ endResponse, fetchAPI, request }) {\n            if (request.url.endsWith(endpoint)) {\n                logger.debug('Responding Health Check');\n                const response = new fetchAPI.Response(null, {\n                    status: 200,\n                    headers: {\n                        'x-yoga-id': id,\n                    },\n                });\n                endResponse(response);\n            }\n        },\n    };\n}\n"],"names":[],"mappings":"AAAO,SAAS,eAAe,EAAE,KAAK,KAAK,IAAG,EAAG,YAAY,SAAS,SAAS,WAAW,UAAS,IAAM,CAAA,GAAI;AACzG,SAAO;AAAA,IACH,UAAU,EAAE,aAAa,UAAU,QAAO,GAAI;AAC1C,UAAI,QAAQ,IAAI,SAAS,QAAQ,GAAG;AAChC,eAAO,MAAM,yBAAyB;AACtC,cAAM,WAAW,IAAI,SAAS,SAAS,MAAM;AAAA,UACzC,QAAQ;AAAA,UACR,SAAS;AAAA,YACL,aAAa;AAAA,UACrC;AAAA,QACA,CAAiB;AACD,oBAAY,QAAQ;AAAA,MACxB;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/use-parser-and-validation-cache.js

@@ -0,0 +1,63 @@
+import { _createLRUCache } from "../utils/create-lru-cache.js";
+function useParserAndValidationCache({ documentCache = _createLRUCache(), errorCache = _createLRUCache(), validationCache = true }) {
+  const validationCacheByRules = _createLRUCache();
+  return {
+    onParse({ params, setParsedDocument }) {
+      const strDocument = params.source.toString();
+      const document = documentCache.get(strDocument);
+      if (document) {
+        setParsedDocument(document);
+        return;
+      }
+      const parserError = errorCache.get(strDocument);
+      if (parserError) {
+        throw parserError;
+      }
+      return ({ result }) => {
+        if (result != null) {
+          if (result instanceof Error) {
+            errorCache.set(strDocument, result);
+          } else {
+            documentCache.set(strDocument, result);
+          }
+        }
+      };
+    },
+    onValidate({
+      params: { schema, documentAST, rules },
+      setResult
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    }) {
+      if (schema == null) {
+        return;
+      }
+      if (validationCache !== false) {
+        const rulesKey = rules?.map((rule) => rule.name).join(",") || "";
+        let validationCacheBySchema = validationCacheByRules.get(rulesKey);
+        if (!validationCacheBySchema) {
+          validationCacheBySchema = /* @__PURE__ */ new WeakMap();
+          validationCacheByRules.set(rulesKey, validationCacheBySchema);
+        }
+        let validationCacheByDocument = validationCacheBySchema.get(schema);
+        if (!validationCacheByDocument) {
+          validationCacheByDocument = /* @__PURE__ */ new WeakMap();
+          validationCacheBySchema.set(schema, validationCacheByDocument);
+        }
+        const cachedResult = validationCacheByDocument.get(documentAST);
+        if (cachedResult) {
+          setResult(cachedResult);
+          return;
+        }
+        return ({ result }) => {
+          if (result != null) {
+            validationCacheByDocument?.set(documentAST, result);
+          }
+        };
+      }
+    }
+  };
+}
+export {
+  useParserAndValidationCache
+};
+//# sourceMappingURL=use-parser-and-validation-cache.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/use-parser-and-validation-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-parser-and-validation-cache.js","sources":["../../../../../node_modules/graphql-yoga/esm/plugins/use-parser-and-validation-cache.js"],"sourcesContent":["import { _createLRUCache } from '../utils/create-lru-cache.js';\nexport function useParserAndValidationCache({ documentCache = _createLRUCache(), errorCache = _createLRUCache(), validationCache = true, }) {\n    const validationCacheByRules = _createLRUCache();\n    return {\n        onParse({ params, setParsedDocument }) {\n            const strDocument = params.source.toString();\n            const document = documentCache.get(strDocument);\n            if (document) {\n                setParsedDocument(document);\n                return;\n            }\n            const parserError = errorCache.get(strDocument);\n            if (parserError) {\n                throw parserError;\n            }\n            return ({ result }) => {\n                if (result != null) {\n                    if (result instanceof Error) {\n                        errorCache.set(strDocument, result);\n                    }\n                    else {\n                        documentCache.set(strDocument, result);\n                    }\n                }\n            };\n        },\n        onValidate({ params: { schema, documentAST, rules }, setResult,\n        // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n         }) {\n            /** No schema no cache */\n            if (schema == null) {\n                return;\n            }\n            if (validationCache !== false) {\n                const rulesKey = rules?.map((rule) => rule.name).join(',') || '';\n                let validationCacheBySchema = validationCacheByRules.get(rulesKey);\n                if (!validationCacheBySchema) {\n                    validationCacheBySchema = new WeakMap();\n                    validationCacheByRules.set(rulesKey, validationCacheBySchema);\n                }\n                let validationCacheByDocument = validationCacheBySchema.get(schema);\n                if (!validationCacheByDocument) {\n                    validationCacheByDocument = new WeakMap();\n                    validationCacheBySchema.set(schema, validationCacheByDocument);\n                }\n                const cachedResult = validationCacheByDocument.get(documentAST);\n                if (cachedResult) {\n                    setResult(cachedResult);\n                    return;\n                }\n                return ({ result }) => {\n                    if (result != null) {\n                        validationCacheByDocument?.set(documentAST, result);\n                    }\n                };\n            }\n        },\n    };\n}\n"],"names":[],"mappings":";AACO,SAAS,4BAA4B,EAAE,gBAAgB,gBAAe,GAAI,aAAa,gBAAe,GAAI,kBAAkB,QAAS;AACxI,QAAM,yBAAyB,gBAAe;AAC9C,SAAO;AAAA,IACH,QAAQ,EAAE,QAAQ,qBAAqB;AACnC,YAAM,cAAc,OAAO,OAAO,SAAQ;AAC1C,YAAM,WAAW,cAAc,IAAI,WAAW;AAC9C,UAAI,UAAU;AACV,0BAAkB,QAAQ;AAC1B;AAAA,MACJ;AACA,YAAM,cAAc,WAAW,IAAI,WAAW;AAC9C,UAAI,aAAa;AACb,cAAM;AAAA,MACV;AACA,aAAO,CAAC,EAAE,aAAa;AACnB,YAAI,UAAU,MAAM;AAChB,cAAI,kBAAkB,OAAO;AACzB,uBAAW,IAAI,aAAa,MAAM;AAAA,UACtC,OACK;AACD,0BAAc,IAAI,aAAa,MAAM;AAAA,UACzC;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAAA,IACA,WAAW;AAAA,MAAE,QAAQ,EAAE,QAAQ,aAAa,MAAK;AAAA,MAAI;AAAA;AAAA,IAE7D,GAAY;AAEA,UAAI,UAAU,MAAM;AAChB;AAAA,MACJ;AACA,UAAI,oBAAoB,OAAO;AAC3B,cAAM,WAAW,OAAO,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,KAAK,GAAG,KAAK;AAC9D,YAAI,0BAA0B,uBAAuB,IAAI,QAAQ;AACjE,YAAI,CAAC,yBAAyB;AAC1B,oCAA0B,oBAAI,QAAO;AACrC,iCAAuB,IAAI,UAAU,uBAAuB;AAAA,QAChE;AACA,YAAI,4BAA4B,wBAAwB,IAAI,MAAM;AAClE,YAAI,CAAC,2BAA2B;AAC5B,sCAA4B,oBAAI,QAAO;AACvC,kCAAwB,IAAI,QAAQ,yBAAyB;AAAA,QACjE;AACA,cAAM,eAAe,0BAA0B,IAAI,WAAW;AAC9D,YAAI,cAAc;AACd,oBAAU,YAAY;AACtB;AAAA,QACJ;AACA,eAAO,CAAC,EAAE,aAAa;AACnB,cAAI,UAAU,MAAM;AAChB,uCAA2B,IAAI,aAAa,MAAM;AAAA,UACtD;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/use-request-parser.js

@@ -0,0 +1,15 @@
+const DEFAULT_MATCHER = () => true;
+function useRequestParser(options) {
+  const matchFn = options.match || DEFAULT_MATCHER;
+  return {
+    onRequestParse({ request, setRequestParser }) {
+      if (matchFn(request)) {
+        setRequestParser(options.parse);
+      }
+    }
+  };
+}
+export {
+  useRequestParser
+};
+//# sourceMappingURL=use-request-parser.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/use-request-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-request-parser.js","sources":["../../../../../node_modules/graphql-yoga/esm/plugins/use-request-parser.js"],"sourcesContent":["const DEFAULT_MATCHER = () => true;\nexport function useRequestParser(options) {\n    const matchFn = options.match || DEFAULT_MATCHER;\n    return {\n        onRequestParse({ request, setRequestParser }) {\n            if (matchFn(request)) {\n                setRequestParser(options.parse);\n            }\n        },\n    };\n}\n"],"names":[],"mappings":"AAAA,MAAM,kBAAkB,MAAM;AACvB,SAAS,iBAAiB,SAAS;AACtC,QAAM,UAAU,QAAQ,SAAS;AACjC,SAAO;AAAA,IACH,eAAe,EAAE,SAAS,oBAAoB;AAC1C,UAAI,QAAQ,OAAO,GAAG;AAClB,yBAAiB,QAAQ,KAAK;AAAA,MAClC;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/use-result-processor.js

@@ -0,0 +1,58 @@
+import { getMediaTypesForRequestInOrder, isMatchingMediaType } from "./result-processor/accept.js";
+import { processMultipartResult } from "./result-processor/multipart.js";
+import { processRegularResult } from "./result-processor/regular.js";
+import { getSSEProcessor } from "./result-processor/sse.js";
+import { isAsyncIterable } from "../../../@envelop/core/esm/utils.js";
+const multipart = {
+  mediaTypes: ["multipart/mixed"],
+  asyncIterables: true,
+  processResult: processMultipartResult
+};
+function getSSEProcessorConfig() {
+  return {
+    mediaTypes: ["text/event-stream"],
+    asyncIterables: true,
+    processResult: getSSEProcessor()
+  };
+}
+const regular = {
+  mediaTypes: ["application/graphql-response+json", "application/json"],
+  asyncIterables: false,
+  processResult: processRegularResult
+};
+function useResultProcessors() {
+  const isSubscriptionRequestMap = /* @__PURE__ */ new WeakMap();
+  const sse = getSSEProcessorConfig();
+  const defaultList = [sse, multipart, regular];
+  const subscriptionList = [sse, regular];
+  return {
+    onSubscribe({ args: { contextValue } }) {
+      if (contextValue.request) {
+        isSubscriptionRequestMap.set(contextValue.request, true);
+      }
+    },
+    onResultProcess({ request, result, acceptableMediaTypes, setResultProcessor }) {
+      const isSubscriptionRequest = isSubscriptionRequestMap.get(request);
+      const processorConfigList = isSubscriptionRequest ? subscriptionList : defaultList;
+      const requestMediaTypes = getMediaTypesForRequestInOrder(request);
+      const isAsyncIterableResult = isAsyncIterable(result);
+      for (const resultProcessorConfig of processorConfigList) {
+        for (const requestMediaType of requestMediaTypes) {
+          if (isAsyncIterableResult && !resultProcessorConfig.asyncIterables) {
+            continue;
+          }
+          for (const processorMediaType of resultProcessorConfig.mediaTypes) {
+            acceptableMediaTypes.push(processorMediaType);
+            if (isMatchingMediaType(processorMediaType, requestMediaType)) {
+              setResultProcessor(resultProcessorConfig.processResult, processorMediaType);
+            }
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  useResultProcessors
+};
+//# sourceMappingURL=use-result-processor.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/use-result-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-result-processor.js","sources":["../../../../../node_modules/graphql-yoga/esm/plugins/use-result-processor.js"],"sourcesContent":["import { isAsyncIterable } from '@envelop/core';\nimport { getMediaTypesForRequestInOrder, isMatchingMediaType } from './result-processor/accept.js';\nimport { processMultipartResult } from './result-processor/multipart.js';\nimport { processRegularResult } from './result-processor/regular.js';\nimport { getSSEProcessor } from './result-processor/sse.js';\nconst multipart = {\n    mediaTypes: ['multipart/mixed'],\n    asyncIterables: true,\n    processResult: processMultipartResult,\n};\nfunction getSSEProcessorConfig() {\n    return {\n        mediaTypes: ['text/event-stream'],\n        asyncIterables: true,\n        processResult: getSSEProcessor(),\n    };\n}\nconst regular = {\n    mediaTypes: ['application/graphql-response+json', 'application/json'],\n    asyncIterables: false,\n    processResult: processRegularResult,\n};\nexport function useResultProcessors() {\n    const isSubscriptionRequestMap = new WeakMap();\n    const sse = getSSEProcessorConfig();\n    const defaultList = [sse, multipart, regular];\n    const subscriptionList = [sse, regular];\n    return {\n        onSubscribe({ args: { contextValue } }) {\n            if (contextValue.request) {\n                isSubscriptionRequestMap.set(contextValue.request, true);\n            }\n        },\n        onResultProcess({ request, result, acceptableMediaTypes, setResultProcessor }) {\n            const isSubscriptionRequest = isSubscriptionRequestMap.get(request);\n            const processorConfigList = isSubscriptionRequest ? subscriptionList : defaultList;\n            const requestMediaTypes = getMediaTypesForRequestInOrder(request);\n            const isAsyncIterableResult = isAsyncIterable(result);\n            for (const resultProcessorConfig of processorConfigList) {\n                for (const requestMediaType of requestMediaTypes) {\n                    if (isAsyncIterableResult && !resultProcessorConfig.asyncIterables) {\n                        continue;\n                    }\n                    for (const processorMediaType of resultProcessorConfig.mediaTypes) {\n                        acceptableMediaTypes.push(processorMediaType);\n                        if (isMatchingMediaType(processorMediaType, requestMediaType)) {\n                            setResultProcessor(resultProcessorConfig.processResult, processorMediaType);\n                        }\n                    }\n                }\n            }\n        },\n    };\n}\n"],"names":[],"mappings":";;;;;AAKA,MAAM,YAAY;AAAA,EACd,YAAY,CAAC,iBAAiB;AAAA,EAC9B,gBAAgB;AAAA,EAChB,eAAe;AACnB;AACA,SAAS,wBAAwB;AAC7B,SAAO;AAAA,IACH,YAAY,CAAC,mBAAmB;AAAA,IAChC,gBAAgB;AAAA,IAChB,eAAe,gBAAe;AAAA,EACtC;AACA;AACA,MAAM,UAAU;AAAA,EACZ,YAAY,CAAC,qCAAqC,kBAAkB;AAAA,EACpE,gBAAgB;AAAA,EAChB,eAAe;AACnB;AACO,SAAS,sBAAsB;AAClC,QAAM,2BAA2B,oBAAI,QAAO;AAC5C,QAAM,MAAM,sBAAqB;AACjC,QAAM,cAAc,CAAC,KAAK,WAAW,OAAO;AAC5C,QAAM,mBAAmB,CAAC,KAAK,OAAO;AACtC,SAAO;AAAA,IACH,YAAY,EAAE,MAAM,EAAE,aAAY,EAAE,GAAI;AACpC,UAAI,aAAa,SAAS;AACtB,iCAAyB,IAAI,aAAa,SAAS,IAAI;AAAA,MAC3D;AAAA,IACJ;AAAA,IACA,gBAAgB,EAAE,SAAS,QAAQ,sBAAsB,mBAAkB,GAAI;AAC3E,YAAM,wBAAwB,yBAAyB,IAAI,OAAO;AAClE,YAAM,sBAAsB,wBAAwB,mBAAmB;AACvE,YAAM,oBAAoB,+BAA+B,OAAO;AAChE,YAAM,wBAAwB,gBAAgB,MAAM;AACpD,iBAAW,yBAAyB,qBAAqB;AACrD,mBAAW,oBAAoB,mBAAmB;AAC9C,cAAI,yBAAyB,CAAC,sBAAsB,gBAAgB;AAChE;AAAA,UACJ;AACA,qBAAW,sBAAsB,sBAAsB,YAAY;AAC/D,iCAAqB,KAAK,kBAAkB;AAC5C,gBAAI,oBAAoB,oBAAoB,gBAAgB,GAAG;AAC3D,iCAAmB,sBAAsB,eAAe,kBAAkB;AAAA,YAC9E;AAAA,UACJ;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/use-schema.js

@@ -0,0 +1,76 @@
+import { handleMaybePromise } from "../../../@whatwg-node/promise-helpers/esm/index.js";
+function isGraphQLSchema(schemaDef) {
+  return schemaDef?.[Symbol.toStringTag] === "GraphQLSchema";
+}
+const useSchema = (schemaDef) => {
+  if (schemaDef == null) {
+    return {};
+  }
+  if (isGraphQLSchema(schemaDef)) {
+    return {
+      onPluginInit({ setSchema }) {
+        setSchema(schemaDef);
+      }
+    };
+  }
+  if ("then" in schemaDef) {
+    let schema;
+    return {
+      onRequestParse() {
+        return {
+          onRequestParseDone() {
+            if (!schema) {
+              return handleMaybePromise(() => schemaDef, (schemaDef2) => {
+                schema = schemaDef2;
+              });
+            }
+          }
+        };
+      },
+      onEnveloped({ setSchema }) {
+        if (schema == null) {
+          throw new Error(`You provide a promise of a schema but it hasn't been resolved yet. Make sure you use this plugin with GraphQL Yoga.`);
+        }
+        if (!isGraphQLSchema(schema)) {
+          throw new Error(`The resolved schema is not a valid GraphQLSchema instance.`);
+        }
+        setSchema(schema);
+      }
+    };
+  }
+  if (typeof schemaDef === "function") {
+    const schemaByRequest = /* @__PURE__ */ new WeakMap();
+    return {
+      onRequestParse({ request, serverContext }) {
+        return {
+          onRequestParseDone() {
+            return handleMaybePromise(() => schemaDef({
+              ...serverContext,
+              request
+            }), (schemaDef2) => {
+              if (!isGraphQLSchema(schemaDef2)) {
+                throw new Error("The factory function did not return a valid GraphQLSchema.");
+              }
+              schemaByRequest.set(request, schemaDef2);
+            });
+          }
+        };
+      },
+      onEnveloped({ setSchema, context }) {
+        if (context?.request == null) {
+          throw new Error("Request object is not available in the context. Make sure you use this plugin with GraphQL Yoga.");
+        }
+        const schema = schemaByRequest.get(context.request);
+        if (schema == null) {
+          throw new Error(`No schema found for this request. Make sure you use this plugin with GraphQL Yoga.`);
+        }
+        setSchema(schema);
+      }
+    };
+  }
+  throw new Error(`Invalid schema definition provided, expected a schema, promise or function.`);
+};
+export {
+  useSchema
+};
+//# sourceMappingURL=use-schema.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/use-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-schema.js","sources":["../../../../../node_modules/graphql-yoga/esm/plugins/use-schema.js"],"sourcesContent":["import { handleMaybePromise } from '@whatwg-node/promise-helpers';\nfunction isGraphQLSchema(schemaDef) {\n    // @ts-expect-error - Symbol.toStringTag exists\n    return schemaDef?.[Symbol.toStringTag] === 'GraphQLSchema';\n}\nexport const useSchema = (schemaDef) => {\n    if (schemaDef == null) {\n        return {};\n    }\n    if (isGraphQLSchema(schemaDef)) {\n        return {\n            onPluginInit({ setSchema }) {\n                setSchema(schemaDef);\n            },\n        };\n    }\n    if ('then' in schemaDef) {\n        let schema;\n        return {\n            onRequestParse() {\n                return {\n                    onRequestParseDone() {\n                        if (!schema) {\n                            return handleMaybePromise(() => schemaDef, schemaDef => {\n                                schema = schemaDef;\n                            });\n                        }\n                    },\n                };\n            },\n            onEnveloped({ setSchema }) {\n                if (schema == null) {\n                    throw new Error(`You provide a promise of a schema but it hasn't been resolved yet. Make sure you use this plugin with GraphQL Yoga.`);\n                }\n                if (!isGraphQLSchema(schema)) {\n                    throw new Error(`The resolved schema is not a valid GraphQLSchema instance.`);\n                }\n                setSchema(schema);\n            },\n        };\n    }\n    if (typeof schemaDef === 'function') {\n        const schemaByRequest = new WeakMap();\n        return {\n            onRequestParse({ request, serverContext }) {\n                return {\n                    onRequestParseDone() {\n                        return handleMaybePromise(() => schemaDef({\n                            ...serverContext,\n                            request,\n                        }), schemaDef => {\n                            if (!isGraphQLSchema(schemaDef)) {\n                                throw new Error('The factory function did not return a valid GraphQLSchema.');\n                            }\n                            schemaByRequest.set(request, schemaDef);\n                        });\n                    },\n                };\n            },\n            onEnveloped({ setSchema, context }) {\n                if (context?.request == null) {\n                    throw new Error('Request object is not available in the context. Make sure you use this plugin with GraphQL Yoga.');\n                }\n                const schema = schemaByRequest.get(context.request);\n                if (schema == null) {\n                    throw new Error(`No schema found for this request. Make sure you use this plugin with GraphQL Yoga.`);\n                }\n                setSchema(schema);\n            },\n        };\n    }\n    throw new Error(`Invalid schema definition provided, expected a schema, promise or function.`);\n};\n"],"names":["schemaDef"],"mappings":";AACA,SAAS,gBAAgB,WAAW;AAEhC,SAAO,YAAY,OAAO,WAAW,MAAM;AAC/C;AACY,MAAC,YAAY,CAAC,cAAc;AACpC,MAAI,aAAa,MAAM;AACnB,WAAO,CAAA;AAAA,EACX;AACA,MAAI,gBAAgB,SAAS,GAAG;AAC5B,WAAO;AAAA,MACH,aAAa,EAAE,aAAa;AACxB,kBAAU,SAAS;AAAA,MACvB;AAAA,IACZ;AAAA,EACI;AACA,MAAI,UAAU,WAAW;AACrB,QAAI;AACJ,WAAO;AAAA,MACH,iBAAiB;AACb,eAAO;AAAA,UACH,qBAAqB;AACjB,gBAAI,CAAC,QAAQ;AACT,qBAAO,mBAAmB,MAAM,WAAW,CAAAA,eAAa;AACpD,yBAASA;AAAA,cACb,CAAC;AAAA,YACL;AAAA,UACJ;AAAA,QACpB;AAAA,MACY;AAAA,MACA,YAAY,EAAE,aAAa;AACvB,YAAI,UAAU,MAAM;AAChB,gBAAM,IAAI,MAAM,qHAAqH;AAAA,QACzI;AACA,YAAI,CAAC,gBAAgB,MAAM,GAAG;AAC1B,gBAAM,IAAI,MAAM,4DAA4D;AAAA,QAChF;AACA,kBAAU,MAAM;AAAA,MACpB;AAAA,IACZ;AAAA,EACI;AACA,MAAI,OAAO,cAAc,YAAY;AACjC,UAAM,kBAAkB,oBAAI,QAAO;AACnC,WAAO;AAAA,MACH,eAAe,EAAE,SAAS,iBAAiB;AACvC,eAAO;AAAA,UACH,qBAAqB;AACjB,mBAAO,mBAAmB,MAAM,UAAU;AAAA,cACtC,GAAG;AAAA,cACH;AAAA,YAC5B,CAAyB,GAAG,CAAAA,eAAa;AACb,kBAAI,CAAC,gBAAgBA,UAAS,GAAG;AAC7B,sBAAM,IAAI,MAAM,4DAA4D;AAAA,cAChF;AACA,8BAAgB,IAAI,SAASA,UAAS;AAAA,YAC1C,CAAC;AAAA,UACL;AAAA,QACpB;AAAA,MACY;AAAA,MACA,YAAY,EAAE,WAAW,WAAW;AAChC,YAAI,SAAS,WAAW,MAAM;AAC1B,gBAAM,IAAI,MAAM,kGAAkG;AAAA,QACtH;AACA,cAAM,SAAS,gBAAgB,IAAI,QAAQ,OAAO;AAClD,YAAI,UAAU,MAAM;AAChB,gBAAM,IAAI,MAAM,oFAAoF;AAAA,QACxG;AACA,kBAAU,MAAM;AAAA,MACpB;AAAA,IACZ;AAAA,EACI;AACA,QAAM,IAAI,MAAM,6EAA6E;AACjG;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/use-unhandled-route.js

@@ -0,0 +1,52 @@
+import landingPageBody from "../landing-page-html.js";
+import { isPromise } from "../../../@whatwg-node/promise-helpers/esm/index.js";
+const defaultRenderLandingPage = function defaultRenderLandingPage2(opts) {
+  return new opts.fetchAPI.Response(landingPageBody.replace(/__GRAPHIQL_LINK__/g, opts.graphqlEndpoint).replace(/__REQUEST_PATH__/g, opts.url.pathname), {
+    status: 200,
+    statusText: "OK",
+    headers: {
+      "Content-Type": "text/html"
+    }
+  });
+};
+function useUnhandledRoute(args) {
+  let urlPattern;
+  function getUrlPattern({ URLPattern }) {
+    urlPattern ||= new URLPattern({
+      pathname: args.graphqlEndpoint
+    });
+    return urlPattern;
+  }
+  const landingPageRenderer = args.landingPageRenderer || defaultRenderLandingPage;
+  return {
+    onRequest({ request, fetchAPI, endResponse, url }) {
+      if (!request.url.endsWith(args.graphqlEndpoint) && !request.url.endsWith(`${args.graphqlEndpoint}/`) && url.pathname !== args.graphqlEndpoint && url.pathname !== `${args.graphqlEndpoint}/` && !getUrlPattern(fetchAPI).test(url)) {
+        if (args.showLandingPage === true && request.method === "GET" && !!request.headers?.get("accept")?.includes("text/html")) {
+          const landingPage$ = landingPageRenderer({
+            request,
+            fetchAPI,
+            url,
+            graphqlEndpoint: args.graphqlEndpoint,
+            get urlPattern() {
+              return getUrlPattern(fetchAPI);
+            }
+          });
+          if (isPromise(landingPage$)) {
+            return landingPage$.then(endResponse);
+          }
+          endResponse(landingPage$);
+          return;
+        }
+        endResponse(new fetchAPI.Response("", {
+          status: 404,
+          statusText: "Not Found"
+        }));
+      }
+    }
+  };
+}
+export {
+  defaultRenderLandingPage,
+  useUnhandledRoute
+};
+//# sourceMappingURL=use-unhandled-route.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/use-unhandled-route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-unhandled-route.js","sources":["../../../../../node_modules/graphql-yoga/esm/plugins/use-unhandled-route.js"],"sourcesContent":["import { isPromise } from '@graphql-tools/utils';\nimport landingPageBody from '../landing-page-html.js';\nexport const defaultRenderLandingPage = function defaultRenderLandingPage(opts) {\n    return new opts.fetchAPI.Response(landingPageBody\n        .replace(/__GRAPHIQL_LINK__/g, opts.graphqlEndpoint)\n        .replace(/__REQUEST_PATH__/g, opts.url.pathname), {\n        status: 200,\n        statusText: 'OK',\n        headers: {\n            'Content-Type': 'text/html',\n        },\n    });\n};\nexport function useUnhandledRoute(args) {\n    let urlPattern;\n    function getUrlPattern({ URLPattern }) {\n        urlPattern ||= new URLPattern({\n            pathname: args.graphqlEndpoint,\n        });\n        return urlPattern;\n    }\n    const landingPageRenderer = args.landingPageRenderer || defaultRenderLandingPage;\n    return {\n        onRequest({ request, fetchAPI, endResponse, url }) {\n            if (!request.url.endsWith(args.graphqlEndpoint) &&\n                !request.url.endsWith(`${args.graphqlEndpoint}/`) &&\n                url.pathname !== args.graphqlEndpoint &&\n                url.pathname !== `${args.graphqlEndpoint}/` &&\n                !getUrlPattern(fetchAPI).test(url)) {\n                if (args.showLandingPage === true &&\n                    request.method === 'GET' &&\n                    !!request.headers?.get('accept')?.includes('text/html')) {\n                    const landingPage$ = landingPageRenderer({\n                        request,\n                        fetchAPI,\n                        url,\n                        graphqlEndpoint: args.graphqlEndpoint,\n                        get urlPattern() {\n                            return getUrlPattern(fetchAPI);\n                        },\n                    });\n                    if (isPromise(landingPage$)) {\n                        return landingPage$.then(endResponse);\n                    }\n                    endResponse(landingPage$);\n                    return;\n                }\n                endResponse(new fetchAPI.Response('', {\n                    status: 404,\n                    statusText: 'Not Found',\n                }));\n            }\n        },\n    };\n}\n"],"names":["defaultRenderLandingPage"],"mappings":";;AAEY,MAAC,2BAA2B,SAASA,0BAAyB,MAAM;AAC5E,SAAO,IAAI,KAAK,SAAS,SAAS,gBAC7B,QAAQ,sBAAsB,KAAK,eAAe,EAClD,QAAQ,qBAAqB,KAAK,IAAI,QAAQ,GAAG;AAAA,IAClD,QAAQ;AAAA,IACR,YAAY;AAAA,IACZ,SAAS;AAAA,MACL,gBAAgB;AAAA,IAC5B;AAAA,EACA,CAAK;AACL;AACO,SAAS,kBAAkB,MAAM;AACpC,MAAI;AACJ,WAAS,cAAc,EAAE,cAAc;AACnC,mBAAe,IAAI,WAAW;AAAA,MAC1B,UAAU,KAAK;AAAA,IAC3B,CAAS;AACD,WAAO;AAAA,EACX;AACA,QAAM,sBAAsB,KAAK,uBAAuB;AACxD,SAAO;AAAA,IACH,UAAU,EAAE,SAAS,UAAU,aAAa,IAAG,GAAI;AAC/C,UAAI,CAAC,QAAQ,IAAI,SAAS,KAAK,eAAe,KAC1C,CAAC,QAAQ,IAAI,SAAS,GAAG,KAAK,eAAe,GAAG,KAChD,IAAI,aAAa,KAAK,mBACtB,IAAI,aAAa,GAAG,KAAK,eAAe,OACxC,CAAC,cAAc,QAAQ,EAAE,KAAK,GAAG,GAAG;AACpC,YAAI,KAAK,oBAAoB,QACzB,QAAQ,WAAW,SACnB,CAAC,CAAC,QAAQ,SAAS,IAAI,QAAQ,GAAG,SAAS,WAAW,GAAG;AACzD,gBAAM,eAAe,oBAAoB;AAAA,YACrC;AAAA,YACA;AAAA,YACA;AAAA,YACA,iBAAiB,KAAK;AAAA,YACtB,IAAI,aAAa;AACb,qBAAO,cAAc,QAAQ;AAAA,YACjC;AAAA,UACxB,CAAqB;AACD,cAAI,UAAU,YAAY,GAAG;AACzB,mBAAO,aAAa,KAAK,WAAW;AAAA,UACxC;AACA,sBAAY,YAAY;AACxB;AAAA,QACJ;AACA,oBAAY,IAAI,SAAS,SAAS,IAAI;AAAA,UAClC,QAAQ;AAAA,UACR,YAAY;AAAA,QAChC,CAAiB,CAAC;AAAA,MACN;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/process-request.js

@@ -0,0 +1,56 @@
+import { handleMaybePromise, iterateAsyncVoid as iterateAsync } from "../../@whatwg-node/promise-helpers/esm/index.js";
+import { getOperationAST } from "../../graphql/utilities/getOperationAST.js";
+function processResult({ request, result, fetchAPI, onResultProcessHooks, serverContext }) {
+  let resultProcessor;
+  const acceptableMediaTypes = [];
+  let acceptedMediaType = "*/*";
+  return handleMaybePromise(() => iterateAsync(onResultProcessHooks, (onResultProcessHook) => onResultProcessHook({
+    request,
+    acceptableMediaTypes,
+    result,
+    setResult(newResult) {
+      result = newResult;
+    },
+    resultProcessor,
+    setResultProcessor(newResultProcessor, newAcceptedMimeType) {
+      resultProcessor = newResultProcessor;
+      acceptedMediaType = newAcceptedMimeType;
+    },
+    serverContext
+  })), () => {
+    if (!resultProcessor) {
+      return new fetchAPI.Response(null, {
+        status: 406,
+        statusText: "Not Acceptable",
+        headers: {
+          accept: acceptableMediaTypes.join("; charset=utf-8, ")
+        }
+      });
+    }
+    return resultProcessor(result, fetchAPI, acceptedMediaType);
+  });
+}
+function processRequest({ params, enveloped }) {
+  const document = enveloped.parse(params.query);
+  const errors = enveloped.validate(enveloped.schema, document);
+  if (errors.length > 0) {
+    return { errors };
+  }
+  return handleMaybePromise(() => enveloped.contextFactory(), (contextValue) => {
+    const executionArgs = {
+      schema: enveloped.schema,
+      document,
+      contextValue,
+      variableValues: params.variables,
+      operationName: params.operationName
+    };
+    const operation = getOperationAST(document, params.operationName);
+    const executeFn = operation?.operation === "subscription" ? enveloped.subscribe : enveloped.execute;
+    return executeFn(executionArgs);
+  });
+}
+export {
+  processRequest,
+  processResult
+};
+//# sourceMappingURL=process-request.js.map

package/dist/node_modules/graphql-yoga/esm/process-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-request.js","sources":["../../../../node_modules/graphql-yoga/esm/process-request.js"],"sourcesContent":["import { getOperationAST } from 'graphql';\nimport { handleMaybePromise, iterateAsync } from '@whatwg-node/promise-helpers';\nexport function processResult({ request, result, fetchAPI, onResultProcessHooks, serverContext, }) {\n    let resultProcessor;\n    const acceptableMediaTypes = [];\n    let acceptedMediaType = '*/*';\n    return handleMaybePromise(() => iterateAsync(onResultProcessHooks, onResultProcessHook => onResultProcessHook({\n        request,\n        acceptableMediaTypes,\n        result,\n        setResult(newResult) {\n            result = newResult;\n        },\n        resultProcessor,\n        setResultProcessor(newResultProcessor, newAcceptedMimeType) {\n            resultProcessor = newResultProcessor;\n            acceptedMediaType = newAcceptedMimeType;\n        },\n        serverContext,\n    })), () => {\n        // If no result processor found for this result, return an error\n        if (!resultProcessor) {\n            return new fetchAPI.Response(null, {\n                status: 406,\n                statusText: 'Not Acceptable',\n                headers: {\n                    accept: acceptableMediaTypes.join('; charset=utf-8, '),\n                },\n            });\n        }\n        return resultProcessor(result, fetchAPI, acceptedMediaType);\n    });\n}\nexport function processRequest({ params, enveloped, }) {\n    // Parse GraphQLParams\n    const document = enveloped.parse(params.query);\n    // Validate parsed Document Node\n    const errors = enveloped.validate(enveloped.schema, document);\n    if (errors.length > 0) {\n        return { errors };\n    }\n    // Build the context for the execution\n    return handleMaybePromise(() => enveloped.contextFactory(), contextValue => {\n        const executionArgs = {\n            schema: enveloped.schema,\n            document,\n            contextValue,\n            variableValues: params.variables,\n            operationName: params.operationName,\n        };\n        // Get the actual operation\n        const operation = getOperationAST(document, params.operationName);\n        // Choose the right executor\n        const executeFn = operation?.operation === 'subscription' ? enveloped.subscribe : enveloped.execute;\n        // Get the result to be processed\n        return executeFn(executionArgs);\n    });\n}\n"],"names":[],"mappings":";;AAEO,SAAS,cAAc,EAAE,SAAS,QAAQ,UAAU,sBAAsB,iBAAkB;AAC/F,MAAI;AACJ,QAAM,uBAAuB,CAAA;AAC7B,MAAI,oBAAoB;AACxB,SAAO,mBAAmB,MAAM,aAAa,sBAAsB,yBAAuB,oBAAoB;AAAA,IAC1G;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,WAAW;AACjB,eAAS;AAAA,IACb;AAAA,IACA;AAAA,IACA,mBAAmB,oBAAoB,qBAAqB;AACxD,wBAAkB;AAClB,0BAAoB;AAAA,IACxB;AAAA,IACA;AAAA,EACR,CAAK,CAAC,GAAG,MAAM;AAEP,QAAI,CAAC,iBAAiB;AAClB,aAAO,IAAI,SAAS,SAAS,MAAM;AAAA,QAC/B,QAAQ;AAAA,QACR,YAAY;AAAA,QACZ,SAAS;AAAA,UACL,QAAQ,qBAAqB,KAAK,mBAAmB;AAAA,QACzE;AAAA,MACA,CAAa;AAAA,IACL;AACA,WAAO,gBAAgB,QAAQ,UAAU,iBAAiB;AAAA,EAC9D,CAAC;AACL;AACO,SAAS,eAAe,EAAE,QAAQ,aAAc;AAEnD,QAAM,WAAW,UAAU,MAAM,OAAO,KAAK;AAE7C,QAAM,SAAS,UAAU,SAAS,UAAU,QAAQ,QAAQ;AAC5D,MAAI,OAAO,SAAS,GAAG;AACnB,WAAO,EAAE,OAAM;AAAA,EACnB;AAEA,SAAO,mBAAmB,MAAM,UAAU,eAAc,GAAI,kBAAgB;AACxE,UAAM,gBAAgB;AAAA,MAClB,QAAQ,UAAU;AAAA,MAClB;AAAA,MACA;AAAA,MACA,gBAAgB,OAAO;AAAA,MACvB,eAAe,OAAO;AAAA,IAClC;AAEQ,UAAM,YAAY,gBAAgB,UAAU,OAAO,aAAa;AAEhE,UAAM,YAAY,WAAW,cAAc,iBAAiB,UAAU,YAAY,UAAU;AAE5F,WAAO,UAAU,aAAa;AAAA,EAClC,CAAC;AACL;","x_google_ignoreList":[0]}