@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/graphql-yoga/esm/server.js

@@ -0,0 +1,374 @@
+import { createLogger } from "../../@graphql-yoga/logger/esm/index.js";
+import * as globalPonyfill from "../../../_virtual/global-ponyfill.js";
+import { handleMaybePromise, unfakePromise, fakePromise, mapAsyncIterator, iterateAsyncVoid as iterateAsync } from "../../@whatwg-node/promise-helpers/esm/index.js";
+import { isAbortError, handleError } from "./error.js";
+import { useAllowedRequestHeaders, useAllowedResponseHeaders } from "./plugins/allowed-headers.js";
+import { isGETRequest, parseGETRequest } from "./plugins/request-parser/get.js";
+import { isPOSTFormUrlEncodedRequest, parsePOSTFormUrlEncodedRequest } from "./plugins/request-parser/post-form-url-encoded.js";
+import { isPOSTGraphQLStringRequest, parsePOSTGraphQLStringRequest } from "./plugins/request-parser/post-graphql-string.js";
+import { isPOSTJsonRequest, parsePOSTJsonRequest } from "./plugins/request-parser/post-json.js";
+import { isPOSTMultipartRequest, parsePOSTMultipartRequest } from "./plugins/request-parser/post-multipart.js";
+import { useCheckGraphQLQueryParams } from "./plugins/request-validation/use-check-graphql-query-params.js";
+import { useCheckMethodForGraphQL } from "./plugins/request-validation/use-check-method-for-graphql.js";
+import { useHTTPValidationError } from "./plugins/request-validation/use-http-validation-error.js";
+import { useLimitBatching } from "./plugins/request-validation/use-limit-batching.js";
+import { usePreventMutationViaGET } from "./plugins/request-validation/use-prevent-mutation-via-get.js";
+import { useGraphiQL } from "./plugins/use-graphiql.js";
+import { useHealthCheck } from "./plugins/use-health-check.js";
+import { useParserAndValidationCache } from "./plugins/use-parser-and-validation-cache.js";
+import { useRequestParser } from "./plugins/use-request-parser.js";
+import { useResultProcessors } from "./plugins/use-result-processor.js";
+import { useSchema } from "./plugins/use-schema.js";
+import { useUnhandledRoute } from "./plugins/use-unhandled-route.js";
+import { processResult, processRequest } from "./process-request.js";
+import { maskError } from "./utils/mask-error.js";
+import { createServerAdapter } from "../../@whatwg-node/server/esm/createServerAdapter.js";
+import { useEngine } from "../../@envelop/core/esm/plugins/use-engine.js";
+import { useExtendContext } from "../../@envelop/core/esm/plugins/use-extend-context.js";
+import { useCORS } from "../../@whatwg-node/server/esm/plugins/useCors.js";
+import { useMaskedErrors } from "../../@envelop/core/esm/plugins/use-masked-errors.js";
+import { envelop } from "../../@envelop/core/esm/create.js";
+import { normalizedExecutor } from "../../@graphql-tools/executor/esm/execution/normalizedExecutor.js";
+import { validate } from "../../graphql/validation/validate.js";
+import { specifiedRules } from "../../graphql/validation/specifiedRules.js";
+import { parse } from "../../graphql/language/parser.js";
+import { chain, getInstrumented } from "../../@envelop/instrumentation/esm/instrumentation.js";
+import { isAsyncIterable } from "../../@envelop/core/esm/utils.js";
+class YogaServer {
+  /**
+   * Instance of envelop
+   */
+  getEnveloped;
+  logger;
+  graphqlEndpoint;
+  fetchAPI;
+  plugins;
+  instrumentation;
+  onRequestParseHooks;
+  onParamsHooks;
+  onExecutionResultHooks;
+  onResultProcessHooks;
+  maskedErrorsOpts;
+  id;
+  version = "5.18.0";
+  constructor(options) {
+    this.id = options?.id ?? "yoga";
+    this.fetchAPI = {
+      ...globalPonyfill
+    };
+    if (options?.fetchAPI) {
+      for (const key in options.fetchAPI) {
+        if (options.fetchAPI[key]) {
+          this.fetchAPI[key] = options.fetchAPI[key];
+        }
+      }
+    }
+    const logger = options?.logging == null ? true : options.logging;
+    this.logger = typeof logger === "boolean" ? logger === true ? createLogger() : createLogger("silent") : typeof logger === "string" ? createLogger(logger) : logger;
+    const maskErrorFn = typeof options?.maskedErrors === "object" && options.maskedErrors.maskError || maskError;
+    const maskedErrorSet = /* @__PURE__ */ new WeakSet();
+    this.maskedErrorsOpts = options?.maskedErrors === false ? null : {
+      errorMessage: "Unexpected error.",
+      ...typeof options?.maskedErrors === "object" ? options.maskedErrors : {},
+      maskError: (error, message) => {
+        if (maskedErrorSet.has(error)) {
+          return error;
+        }
+        const newError = maskErrorFn(error, message, this.maskedErrorsOpts?.isDev);
+        if (newError !== error) {
+          this.logger.error(error);
+        }
+        maskedErrorSet.add(newError);
+        return newError;
+      }
+    };
+    const maskedErrors = this.maskedErrorsOpts == null ? null : this.maskedErrorsOpts;
+    let batchingLimit = 0;
+    if (options?.batching) {
+      if (typeof options.batching === "boolean") {
+        batchingLimit = 10;
+      } else {
+        batchingLimit = options.batching.limit ?? 10;
+      }
+    }
+    this.graphqlEndpoint = options?.graphqlEndpoint || "/graphql";
+    const graphqlEndpoint = this.graphqlEndpoint;
+    this.plugins = [
+      useEngine({
+        parse,
+        validate,
+        execute: normalizedExecutor,
+        subscribe: normalizedExecutor,
+        specifiedRules
+      }),
+      // Use the schema provided by the user
+      !!options?.schema && useSchema(options.schema),
+      options?.allowedHeaders?.request != null && useAllowedRequestHeaders(options.allowedHeaders.request),
+      options?.context != null && useExtendContext((initialContext) => {
+        if (options?.context) {
+          if (typeof options.context === "function") {
+            return options.context(initialContext);
+          }
+          return options.context;
+        }
+        return {};
+      }),
+      // Middlewares before processing the incoming HTTP request
+      useHealthCheck({
+        id: this.id,
+        logger: this.logger,
+        endpoint: options?.healthCheckEndpoint
+      }),
+      options?.cors !== false && useCORS(options?.cors),
+      options?.graphiql !== false && useGraphiQL({
+        graphqlEndpoint,
+        options: options?.graphiql,
+        render: options?.renderGraphiQL,
+        logger: this.logger
+      }),
+      // Middlewares before the GraphQL execution
+      useRequestParser({
+        match: isGETRequest,
+        parse: parseGETRequest
+      }),
+      useRequestParser({
+        match: isPOSTJsonRequest,
+        parse: parsePOSTJsonRequest
+      }),
+      options?.multipart !== false && useRequestParser({
+        match: isPOSTMultipartRequest,
+        parse: parsePOSTMultipartRequest
+      }),
+      useRequestParser({
+        match: isPOSTGraphQLStringRequest,
+        parse: parsePOSTGraphQLStringRequest
+      }),
+      useRequestParser({
+        match: isPOSTFormUrlEncodedRequest,
+        parse: parsePOSTFormUrlEncodedRequest
+      }),
+      // Middlewares after the GraphQL execution
+      useResultProcessors(),
+      ...options?.plugins ?? [],
+      options?.parserAndValidationCache !== false && useParserAndValidationCache(!options?.parserAndValidationCache || options?.parserAndValidationCache === true ? {} : options?.parserAndValidationCache),
+      useLimitBatching(batchingLimit),
+      useCheckGraphQLQueryParams(options?.extraParamNames),
+      useUnhandledRoute({
+        graphqlEndpoint,
+        showLandingPage: options?.landingPage !== false,
+        landingPageRenderer: typeof options?.landingPage === "function" ? options.landingPage : void 0
+      }),
+      // We check the method after user-land plugins because the plugin might support more methods (like graphql-sse).
+      useCheckMethodForGraphQL(),
+      // We make sure that the user doesn't send a mutation with GET
+      usePreventMutationViaGET(),
+      // Make sure we always throw AbortError instead of masking it!
+      maskedErrors !== null && {
+        onSubscribe() {
+          return {
+            onSubscribeError({ error }) {
+              if (isAbortError(error)) {
+                throw error;
+              }
+            }
+          };
+        }
+      },
+      maskedErrors !== null && useMaskedErrors(maskedErrors),
+      options?.allowedHeaders?.response != null && useAllowedResponseHeaders(options.allowedHeaders.response),
+      // We handle validation errors at the end
+      useHTTPValidationError()
+    ];
+    this.getEnveloped = envelop({
+      plugins: this.plugins
+    });
+    this.plugins = this.getEnveloped._plugins;
+    this.onRequestParseHooks = [];
+    this.onParamsHooks = [];
+    this.onExecutionResultHooks = [];
+    this.onResultProcessHooks = [];
+    for (const plugin of this.plugins) {
+      if (plugin) {
+        if (plugin.onYogaInit) {
+          plugin.onYogaInit({
+            yoga: this
+          });
+        }
+        if (plugin.onRequestParse) {
+          this.onRequestParseHooks.push(plugin.onRequestParse);
+        }
+        if (plugin.onParams) {
+          this.onParamsHooks.push(plugin.onParams);
+        }
+        if (plugin.onExecutionResult) {
+          this.onExecutionResultHooks.push(plugin.onExecutionResult);
+        }
+        if (plugin.onResultProcess) {
+          this.onResultProcessHooks.push(plugin.onResultProcess);
+        }
+        if (plugin.instrumentation) {
+          this.instrumentation = this.instrumentation ? chain(this.instrumentation, plugin.instrumentation) : plugin.instrumentation;
+        }
+      }
+    }
+  }
+  handleParams = ({ request, context, params }) => {
+    const additionalContext = context["request"] === request ? {
+      params
+    } : {
+      request,
+      params
+    };
+    Object.assign(context, additionalContext);
+    const enveloped = this.getEnveloped(context);
+    this.logger.debug(`Processing GraphQL Parameters`);
+    return handleMaybePromise(() => handleMaybePromise(() => processRequest({ params, enveloped }), (result) => {
+      this.logger.debug(`Processing GraphQL Parameters done.`);
+      return result;
+    }, (error) => {
+      const errors = handleError(error, this.maskedErrorsOpts, this.logger);
+      return {
+        errors
+      };
+    }), (result) => {
+      if (isAsyncIterable(result)) {
+        result = mapAsyncIterator(result, (v) => v, (error) => {
+          if (error.name === "AbortError") {
+            this.logger.debug(`Request aborted`);
+            throw error;
+          }
+          const errors = handleError(error, this.maskedErrorsOpts, this.logger);
+          return {
+            errors
+          };
+        });
+      }
+      return result;
+    });
+  };
+  getResultForParams = ({ params, request }, context) => {
+    let result;
+    let paramsHandler = this.handleParams;
+    return handleMaybePromise(() => iterateAsync(this.onParamsHooks, (onParamsHook) => onParamsHook({
+      params,
+      request,
+      setParams(newParams) {
+        params = newParams;
+      },
+      paramsHandler,
+      setParamsHandler(newHandler) {
+        paramsHandler = newHandler;
+      },
+      setResult(newResult) {
+        result = newResult;
+      },
+      fetchAPI: this.fetchAPI,
+      context
+    })), () => handleMaybePromise(() => result || paramsHandler({
+      request,
+      params,
+      context
+    }), (result2) => handleMaybePromise(() => iterateAsync(this.onExecutionResultHooks, (onExecutionResult) => onExecutionResult({
+      result: result2,
+      setResult(newResult) {
+        result2 = newResult;
+      },
+      request,
+      context
+    })), () => result2)));
+  };
+  parseRequest = (request, serverContext) => {
+    let url = new Proxy({}, {
+      get: (_target, prop, _receiver) => {
+        url = new this.fetchAPI.URL(request.url, "http://localhost");
+        return Reflect.get(url, prop, url);
+      }
+    });
+    let requestParser;
+    const onRequestParseDoneList = [];
+    return handleMaybePromise(() => iterateAsync(this.onRequestParseHooks, (onRequestParse) => handleMaybePromise(() => onRequestParse({
+      request,
+      url,
+      requestParser,
+      serverContext,
+      setRequestParser(parser) {
+        requestParser = parser;
+      }
+    }), (requestParseHookResult) => requestParseHookResult?.onRequestParseDone), onRequestParseDoneList), () => {
+      this.logger.debug(`Parsing request to extract GraphQL parameters`);
+      if (!requestParser) {
+        return {
+          response: new this.fetchAPI.Response(null, {
+            status: 415,
+            statusText: "Unsupported Media Type"
+          })
+        };
+      }
+      return handleMaybePromise(() => requestParser(request), (requestParserResult) => {
+        return handleMaybePromise(() => iterateAsync(onRequestParseDoneList, (onRequestParseDone) => onRequestParseDone({
+          requestParserResult,
+          setRequestParserResult(newParams) {
+            requestParserResult = newParams;
+          }
+        })), () => ({
+          requestParserResult
+        }));
+      });
+    });
+  };
+  handle = (request, serverContext) => {
+    const instrumented = this.instrumentation && getInstrumented({ request });
+    const parseRequest = this.instrumentation?.requestParse ? instrumented.asyncFn(this.instrumentation?.requestParse, this.parseRequest) : this.parseRequest;
+    return unfakePromise(fakePromise().then(() => parseRequest(request, serverContext)).then(({ response, requestParserResult }) => {
+      if (response) {
+        return response;
+      }
+      const getResultForParams = this.instrumentation?.operation ? (payload, context) => {
+        const instrumented2 = getInstrumented({ context, request: payload.request });
+        const tracedHandler = instrumented2.asyncFn(this.instrumentation?.operation, this.getResultForParams);
+        return tracedHandler(payload, context);
+      } : this.getResultForParams;
+      return handleMaybePromise(() => Array.isArray(requestParserResult) ? Promise.all(requestParserResult.map((params) => getResultForParams({
+        params,
+        request
+      }, Object.create(serverContext)))) : getResultForParams({
+        params: requestParserResult,
+        request
+      }, serverContext), (result) => {
+        const tracedProcessResult = this.instrumentation?.resultProcess ? instrumented.asyncFn(this.instrumentation.resultProcess, processResult) : processResult;
+        return tracedProcessResult({
+          request,
+          result,
+          fetchAPI: this.fetchAPI,
+          onResultProcessHooks: this.onResultProcessHooks,
+          serverContext
+        });
+      });
+    }).catch((error) => {
+      const errors = handleError(error, this.maskedErrorsOpts, this.logger);
+      const result = {
+        errors
+      };
+      return processResult({
+        request,
+        result,
+        fetchAPI: this.fetchAPI,
+        onResultProcessHooks: this.onResultProcessHooks,
+        serverContext
+      });
+    }));
+  };
+}
+function createYoga(options) {
+  const server = new YogaServer(options);
+  return createServerAdapter(server, {
+    fetchAPI: server.fetchAPI,
+    plugins: server["plugins"],
+    disposeOnProcessTerminate: options.disposeOnProcessTerminate
+  });
+}
+export {
+  YogaServer,
+  createYoga
+};
+//# sourceMappingURL=server.js.map

package/dist/node_modules/graphql-yoga/esm/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sources":["../../../../node_modules/graphql-yoga/esm/server.js"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { parse, specifiedRules, validate } from 'graphql';\nimport { envelop, isAsyncIterable, useEngine, useExtendContext, useMaskedErrors, } from '@envelop/core';\nimport { chain, getInstrumented } from '@envelop/instrumentation';\nimport { normalizedExecutor } from '@graphql-tools/executor';\nimport { createLogger } from '@graphql-yoga/logger';\nimport * as defaultFetchAPI from '@whatwg-node/fetch';\nimport { fakePromise, handleMaybePromise, iterateAsync, iterateAsyncVoid, mapAsyncIterator, unfakePromise, } from '@whatwg-node/promise-helpers';\nimport { createServerAdapter, useCORS, } from '@whatwg-node/server';\nimport { handleError, isAbortError } from './error.js';\nimport { useAllowedRequestHeaders, useAllowedResponseHeaders } from './plugins/allowed-headers.js';\nimport { isGETRequest, parseGETRequest } from './plugins/request-parser/get.js';\nimport { isPOSTFormUrlEncodedRequest, parsePOSTFormUrlEncodedRequest, } from './plugins/request-parser/post-form-url-encoded.js';\nimport { isPOSTGraphQLStringRequest, parsePOSTGraphQLStringRequest, } from './plugins/request-parser/post-graphql-string.js';\nimport { isPOSTJsonRequest, parsePOSTJsonRequest } from './plugins/request-parser/post-json.js';\nimport { isPOSTMultipartRequest, parsePOSTMultipartRequest, } from './plugins/request-parser/post-multipart.js';\nimport { useCheckGraphQLQueryParams } from './plugins/request-validation/use-check-graphql-query-params.js';\nimport { useCheckMethodForGraphQL } from './plugins/request-validation/use-check-method-for-graphql.js';\nimport { useHTTPValidationError } from './plugins/request-validation/use-http-validation-error.js';\nimport { useLimitBatching } from './plugins/request-validation/use-limit-batching.js';\nimport { usePreventMutationViaGET } from './plugins/request-validation/use-prevent-mutation-via-get.js';\nimport { useGraphiQL } from './plugins/use-graphiql.js';\nimport { useHealthCheck } from './plugins/use-health-check.js';\nimport { useParserAndValidationCache, } from './plugins/use-parser-and-validation-cache.js';\nimport { useRequestParser } from './plugins/use-request-parser.js';\nimport { useResultProcessors } from './plugins/use-result-processor.js';\nimport { useSchema } from './plugins/use-schema.js';\nimport { useUnhandledRoute } from './plugins/use-unhandled-route.js';\nimport { processRequest as processGraphQLParams, processResult } from './process-request.js';\nimport { maskError } from './utils/mask-error.js';\n/**\n * Base class that can be extended to create a GraphQL server with any HTTP server framework.\n * @internal\n */\nexport class YogaServer {\n    /**\n     * Instance of envelop\n     */\n    getEnveloped;\n    logger;\n    graphqlEndpoint;\n    fetchAPI;\n    plugins;\n    instrumentation;\n    onRequestParseHooks;\n    onParamsHooks;\n    onExecutionResultHooks;\n    onResultProcessHooks;\n    maskedErrorsOpts;\n    id;\n    version = '5.18.0';\n    constructor(options) {\n        this.id = options?.id ?? 'yoga';\n        this.fetchAPI = {\n            ...defaultFetchAPI,\n        };\n        if (options?.fetchAPI) {\n            for (const key in options.fetchAPI) {\n                if (options.fetchAPI[key]) {\n                    this.fetchAPI[key] = options.fetchAPI[key];\n                }\n            }\n        }\n        const logger = options?.logging == null ? true : options.logging;\n        this.logger =\n            typeof logger === 'boolean'\n                ? logger === true\n                    ? createLogger()\n                    : createLogger('silent')\n                : typeof logger === 'string'\n                    ? createLogger(logger)\n                    : logger;\n        const maskErrorFn = (typeof options?.maskedErrors === 'object' && options.maskedErrors.maskError) || maskError;\n        const maskedErrorSet = new WeakSet();\n        this.maskedErrorsOpts =\n            options?.maskedErrors === false\n                ? null\n                : {\n                    errorMessage: 'Unexpected error.',\n                    ...(typeof options?.maskedErrors === 'object' ? options.maskedErrors : {}),\n                    maskError: (error, message) => {\n                        if (maskedErrorSet.has(error)) {\n                            return error;\n                        }\n                        const newError = maskErrorFn(error, message, this.maskedErrorsOpts?.isDev);\n                        if (newError !== error) {\n                            this.logger.error(error);\n                        }\n                        maskedErrorSet.add(newError);\n                        return newError;\n                    },\n                };\n        const maskedErrors = this.maskedErrorsOpts == null ? null : this.maskedErrorsOpts;\n        let batchingLimit = 0;\n        if (options?.batching) {\n            if (typeof options.batching === 'boolean') {\n                batchingLimit = 10;\n            }\n            else {\n                batchingLimit = options.batching.limit ?? 10;\n            }\n        }\n        this.graphqlEndpoint = options?.graphqlEndpoint || '/graphql';\n        const graphqlEndpoint = this.graphqlEndpoint;\n        this.plugins = [\n            useEngine({\n                parse,\n                validate,\n                execute: normalizedExecutor,\n                subscribe: normalizedExecutor,\n                specifiedRules,\n            }),\n            // Use the schema provided by the user\n            !!options?.schema && useSchema(options.schema),\n            options?.allowedHeaders?.request != null &&\n                useAllowedRequestHeaders(options.allowedHeaders.request),\n            options?.context != null &&\n                useExtendContext(initialContext => {\n                    if (options?.context) {\n                        if (typeof options.context === 'function') {\n                            return options.context(initialContext);\n                        }\n                        return options.context;\n                    }\n                    return {};\n                }),\n            // Middlewares before processing the incoming HTTP request\n            useHealthCheck({\n                id: this.id,\n                logger: this.logger,\n                endpoint: options?.healthCheckEndpoint,\n            }),\n            options?.cors !== false && useCORS(options?.cors),\n            options?.graphiql !== false &&\n                useGraphiQL({\n                    graphqlEndpoint,\n                    options: options?.graphiql,\n                    render: options?.renderGraphiQL,\n                    logger: this.logger,\n                }),\n            // Middlewares before the GraphQL execution\n            useRequestParser({\n                match: isGETRequest,\n                parse: parseGETRequest,\n            }),\n            useRequestParser({\n                match: isPOSTJsonRequest,\n                parse: parsePOSTJsonRequest,\n            }),\n            options?.multipart !== false &&\n                useRequestParser({\n                    match: isPOSTMultipartRequest,\n                    parse: parsePOSTMultipartRequest,\n                }),\n            useRequestParser({\n                match: isPOSTGraphQLStringRequest,\n                parse: parsePOSTGraphQLStringRequest,\n            }),\n            useRequestParser({\n                match: isPOSTFormUrlEncodedRequest,\n                parse: parsePOSTFormUrlEncodedRequest,\n            }),\n            // Middlewares after the GraphQL execution\n            useResultProcessors(),\n            ...(options?.plugins ?? []),\n            options?.parserAndValidationCache !== false &&\n                useParserAndValidationCache(!options?.parserAndValidationCache || options?.parserAndValidationCache === true\n                    ? {}\n                    : options?.parserAndValidationCache),\n            useLimitBatching(batchingLimit),\n            useCheckGraphQLQueryParams(options?.extraParamNames),\n            useUnhandledRoute({\n                graphqlEndpoint,\n                showLandingPage: options?.landingPage !== false,\n                landingPageRenderer: typeof options?.landingPage === 'function' ? options.landingPage : undefined,\n            }),\n            // We check the method after user-land plugins because the plugin might support more methods (like graphql-sse).\n            useCheckMethodForGraphQL(),\n            // We make sure that the user doesn't send a mutation with GET\n            usePreventMutationViaGET(),\n            // Make sure we always throw AbortError instead of masking it!\n            maskedErrors !== null && {\n                onSubscribe() {\n                    return {\n                        onSubscribeError({ error }) {\n                            if (isAbortError(error)) {\n                                throw error;\n                            }\n                        },\n                    };\n                },\n            },\n            maskedErrors !== null && useMaskedErrors(maskedErrors),\n            options?.allowedHeaders?.response != null &&\n                useAllowedResponseHeaders(options.allowedHeaders.response),\n            // We handle validation errors at the end\n            useHTTPValidationError(),\n        ];\n        this.getEnveloped = envelop({\n            plugins: this.plugins,\n        });\n        this.plugins = this.getEnveloped._plugins;\n        this.onRequestParseHooks = [];\n        this.onParamsHooks = [];\n        this.onExecutionResultHooks = [];\n        this.onResultProcessHooks = [];\n        for (const plugin of this.plugins) {\n            if (plugin) {\n                if (plugin.onYogaInit) {\n                    plugin.onYogaInit({\n                        yoga: this,\n                    });\n                }\n                if (plugin.onRequestParse) {\n                    this.onRequestParseHooks.push(plugin.onRequestParse);\n                }\n                if (plugin.onParams) {\n                    this.onParamsHooks.push(plugin.onParams);\n                }\n                if (plugin.onExecutionResult) {\n                    this.onExecutionResultHooks.push(plugin.onExecutionResult);\n                }\n                if (plugin.onResultProcess) {\n                    this.onResultProcessHooks.push(plugin.onResultProcess);\n                }\n                if (plugin.instrumentation) {\n                    this.instrumentation = this.instrumentation\n                        ? chain(this.instrumentation, plugin.instrumentation)\n                        : plugin.instrumentation;\n                }\n            }\n        }\n    }\n    handleParams = ({ request, context, params }) => {\n        const additionalContext = context['request'] === request\n            ? {\n                params,\n            }\n            : {\n                request,\n                params,\n            };\n        Object.assign(context, additionalContext);\n        const enveloped = this.getEnveloped(context);\n        this.logger.debug(`Processing GraphQL Parameters`);\n        return handleMaybePromise(() => handleMaybePromise(() => processGraphQLParams({ params, enveloped }), result => {\n            this.logger.debug(`Processing GraphQL Parameters done.`);\n            return result;\n        }, error => {\n            const errors = handleError(error, this.maskedErrorsOpts, this.logger);\n            return {\n                errors,\n            };\n        }), result => {\n            if (isAsyncIterable(result)) {\n                result = mapAsyncIterator(result, v => v, (error) => {\n                    if (error.name === 'AbortError') {\n                        this.logger.debug(`Request aborted`);\n                        throw error;\n                    }\n                    const errors = handleError(error, this.maskedErrorsOpts, this.logger);\n                    return {\n                        errors,\n                    };\n                });\n            }\n            return result;\n        });\n    };\n    getResultForParams = ({ params, request, }, context) => {\n        let result;\n        let paramsHandler = this.handleParams;\n        return handleMaybePromise(() => iterateAsync(this.onParamsHooks, onParamsHook => onParamsHook({\n            params,\n            request,\n            setParams(newParams) {\n                params = newParams;\n            },\n            paramsHandler,\n            setParamsHandler(newHandler) {\n                paramsHandler = newHandler;\n            },\n            setResult(newResult) {\n                result = newResult;\n            },\n            fetchAPI: this.fetchAPI,\n            context,\n        })), () => handleMaybePromise(() => result ||\n            paramsHandler({\n                request,\n                params,\n                context: context,\n            }), result => handleMaybePromise(() => iterateAsync(this.onExecutionResultHooks, onExecutionResult => onExecutionResult({\n            result,\n            setResult(newResult) {\n                result = newResult;\n            },\n            request,\n            context: context,\n        })), () => result)));\n    };\n    parseRequest = (request, serverContext) => {\n        let url = new Proxy({}, {\n            get: (_target, prop, _receiver) => {\n                url = new this.fetchAPI.URL(request.url, 'http://localhost');\n                return Reflect.get(url, prop, url);\n            },\n        });\n        let requestParser;\n        const onRequestParseDoneList = [];\n        return handleMaybePromise(() => iterateAsync(this.onRequestParseHooks, onRequestParse => handleMaybePromise(() => onRequestParse({\n            request,\n            url,\n            requestParser,\n            serverContext,\n            setRequestParser(parser) {\n                requestParser = parser;\n            },\n        }), requestParseHookResult => requestParseHookResult?.onRequestParseDone), onRequestParseDoneList), () => {\n            this.logger.debug(`Parsing request to extract GraphQL parameters`);\n            if (!requestParser) {\n                return {\n                    response: new this.fetchAPI.Response(null, {\n                        status: 415,\n                        statusText: 'Unsupported Media Type',\n                    }),\n                };\n            }\n            return handleMaybePromise(() => requestParser(request), requestParserResult => {\n                return handleMaybePromise(() => iterateAsyncVoid(onRequestParseDoneList, onRequestParseDone => onRequestParseDone({\n                    requestParserResult,\n                    setRequestParserResult(newParams) {\n                        requestParserResult = newParams;\n                    },\n                })), () => ({\n                    requestParserResult,\n                }));\n            });\n        });\n    };\n    handle = (request, serverContext) => {\n        const instrumented = this.instrumentation && getInstrumented({ request });\n        const parseRequest = this.instrumentation?.requestParse\n            ? instrumented.asyncFn(this.instrumentation?.requestParse, this.parseRequest)\n            : this.parseRequest;\n        return unfakePromise(fakePromise()\n            .then(() => parseRequest(request, serverContext))\n            .then(({ response, requestParserResult }) => {\n            if (response) {\n                return response;\n            }\n            const getResultForParams = this.instrumentation?.operation\n                ? (payload, context) => {\n                    const instrumented = getInstrumented({ context, request: payload.request });\n                    const tracedHandler = instrumented.asyncFn(this.instrumentation?.operation, this.getResultForParams);\n                    return tracedHandler(payload, context);\n                }\n                : this.getResultForParams;\n            return handleMaybePromise(() => (Array.isArray(requestParserResult)\n                ? Promise.all(requestParserResult.map(params => getResultForParams({\n                    params,\n                    request,\n                }, Object.create(serverContext))))\n                : getResultForParams({\n                    params: requestParserResult,\n                    request,\n                }, serverContext)), result => {\n                const tracedProcessResult = this.instrumentation?.resultProcess\n                    ? instrumented.asyncFn(this.instrumentation.resultProcess, (processResult))\n                    : processResult;\n                return tracedProcessResult({\n                    request,\n                    result,\n                    fetchAPI: this.fetchAPI,\n                    onResultProcessHooks: this.onResultProcessHooks,\n                    serverContext,\n                });\n            });\n        })\n            .catch(error => {\n            const errors = handleError(error, this.maskedErrorsOpts, this.logger);\n            const result = {\n                errors,\n            };\n            return processResult({\n                request,\n                result,\n                fetchAPI: this.fetchAPI,\n                onResultProcessHooks: this.onResultProcessHooks,\n                serverContext,\n            });\n        }));\n    };\n}\nexport function createYoga(options) {\n    const server = new YogaServer(options);\n    return createServerAdapter(server, {\n        fetchAPI: server.fetchAPI,\n        plugins: server['plugins'],\n        disposeOnProcessTerminate: options.disposeOnProcessTerminate,\n    });\n}\n"],"names":["defaultFetchAPI","processGraphQLParams","result","iterateAsyncVoid","instrumented"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/utils/create-lru-cache.js

@@ -0,0 +1,10 @@
+import { LRUCache } from "../../node_modules/lru-cache/dist/esm/index.js";
+const DEFAULT_MAX = 1024;
+const DEFAULT_TTL = 36e5;
+function _createLRUCache({ max = DEFAULT_MAX, ttl = DEFAULT_TTL } = {}) {
+  return new LRUCache({ max, ttl });
+}
+export {
+  _createLRUCache
+};
+//# sourceMappingURL=create-lru-cache.js.map

package/dist/node_modules/graphql-yoga/esm/utils/create-lru-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lru-cache.js","sources":["../../../../../node_modules/graphql-yoga/esm/utils/create-lru-cache.js"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-object-type */\nimport { LRUCache as LRU } from 'lru-cache';\n/**\n * @deprecated In the next major, `createLRUCache` will be renamed to `_createLRUCache`,\n * and the current `createLRUCache` will be removed.\n */\nexport const createLRUCache = _createLRUCache;\nconst DEFAULT_MAX = 1024;\nconst DEFAULT_TTL = 3_600_000;\n/**\n * @internal This is an internal utility, and you should use it with your own risk.\n * This utility can have breaking changes in the future.\n */\nexport function _createLRUCache({ max = DEFAULT_MAX, ttl = DEFAULT_TTL, } = {}) {\n    return new LRU({ max, ttl });\n}\n"],"names":["LRU"],"mappings":";AAOA,MAAM,cAAc;AACpB,MAAM,cAAc;AAKb,SAAS,gBAAgB,EAAE,MAAM,aAAa,MAAM,YAAW,IAAM,IAAI;AAC5E,SAAO,IAAIA,SAAI,EAAE,KAAK,IAAG,CAAE;AAC/B;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/utils/mask-error.js

@@ -0,0 +1,47 @@
+import { isOriginalGraphQLError, isGraphQLError } from "../error.js";
+import { getSchemaCoordinate, createGraphQLError } from "../../../@graphql-tools/utils/esm/errors.js";
+function serializeError(error) {
+  if (isGraphQLError(error)) {
+    return error.toJSON();
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      cause: error.cause
+    };
+  }
+  return error;
+}
+const maskError = (error, message, isDev = globalThis.process?.env?.["NODE_ENV"] === "development") => {
+  if (isOriginalGraphQLError(error)) {
+    return error;
+  }
+  const errorExtensions = {
+    code: "INTERNAL_SERVER_ERROR",
+    unexpected: true
+  };
+  const errorOptions = {
+    extensions: errorExtensions
+  };
+  if (isGraphQLError(error)) {
+    errorOptions.nodes = error.nodes;
+    errorOptions.source = error.source;
+    errorOptions.positions = error.positions;
+    errorOptions.path = error.path;
+    errorOptions.coordinate = getSchemaCoordinate(error);
+    if (isDev && error.originalError) {
+      errorExtensions["originalError"] = serializeError(error.originalError);
+    }
+    if (error.extensions?.["http"]) {
+      errorExtensions["http"] = error.extensions["http"];
+    }
+  } else if (isDev) {
+    errorExtensions["originalError"] = serializeError(error);
+  }
+  return createGraphQLError(message, errorOptions);
+};
+export {
+  maskError
+};
+//# sourceMappingURL=mask-error.js.map

package/dist/node_modules/graphql-yoga/esm/utils/mask-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask-error.js","sources":["../../../../../node_modules/graphql-yoga/esm/utils/mask-error.js"],"sourcesContent":["import { createGraphQLError, getSchemaCoordinate } from '@graphql-tools/utils';\nimport { isGraphQLError, isOriginalGraphQLError } from '../error.js';\nfunction serializeError(error) {\n    if (isGraphQLError(error)) {\n        return error.toJSON();\n    }\n    if (error instanceof Error) {\n        return {\n            message: error.message,\n            stack: error.stack,\n            cause: error.cause,\n        };\n    }\n    return error;\n}\nexport const maskError = (error, message, isDev = globalThis.process?.env?.['NODE_ENV'] === 'development') => {\n    if (isOriginalGraphQLError(error)) {\n        return error;\n    }\n    const errorExtensions = {\n        code: 'INTERNAL_SERVER_ERROR',\n        unexpected: true,\n    };\n    const errorOptions = {\n        extensions: errorExtensions,\n    };\n    if (isGraphQLError(error)) {\n        errorOptions.nodes = error.nodes;\n        errorOptions.source = error.source;\n        errorOptions.positions = error.positions;\n        errorOptions.path = error.path;\n        errorOptions.coordinate = getSchemaCoordinate(error);\n        if (isDev && error.originalError) {\n            errorExtensions['originalError'] = serializeError(error.originalError);\n        }\n        if (error.extensions?.['http']) {\n            errorExtensions['http'] = error.extensions['http'];\n        }\n    }\n    else if (isDev) {\n        errorExtensions['originalError'] = serializeError(error);\n    }\n    return createGraphQLError(message, errorOptions);\n};\n"],"names":[],"mappings":";;AAEA,SAAS,eAAe,OAAO;AAC3B,MAAI,eAAe,KAAK,GAAG;AACvB,WAAO,MAAM,OAAM;AAAA,EACvB;AACA,MAAI,iBAAiB,OAAO;AACxB,WAAO;AAAA,MACH,SAAS,MAAM;AAAA,MACf,OAAO,MAAM;AAAA,MACb,OAAO,MAAM;AAAA,IACzB;AAAA,EACI;AACA,SAAO;AACX;AACY,MAAC,YAAY,CAAC,OAAO,SAAS,QAAQ,WAAW,SAAS,MAAM,UAAU,MAAM,kBAAkB;AAC1G,MAAI,uBAAuB,KAAK,GAAG;AAC/B,WAAO;AAAA,EACX;AACA,QAAM,kBAAkB;AAAA,IACpB,MAAM;AAAA,IACN,YAAY;AAAA,EACpB;AACI,QAAM,eAAe;AAAA,IACjB,YAAY;AAAA,EACpB;AACI,MAAI,eAAe,KAAK,GAAG;AACvB,iBAAa,QAAQ,MAAM;AAC3B,iBAAa,SAAS,MAAM;AAC5B,iBAAa,YAAY,MAAM;AAC/B,iBAAa,OAAO,MAAM;AAC1B,iBAAa,aAAa,oBAAoB,KAAK;AACnD,QAAI,SAAS,MAAM,eAAe;AAC9B,sBAAgB,eAAe,IAAI,eAAe,MAAM,aAAa;AAAA,IACzE;AACA,QAAI,MAAM,aAAa,MAAM,GAAG;AAC5B,sBAAgB,MAAM,IAAI,MAAM,WAAW,MAAM;AAAA,IACrD;AAAA,EACJ,WACS,OAAO;AACZ,oBAAgB,eAAe,IAAI,eAAe,KAAK;AAAA,EAC3D;AACA,SAAO,mBAAmB,SAAS,YAAY;AACnD;","x_google_ignoreList":[0]}