@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

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

@@ -0,0 +1,78 @@
+import { handleMaybePromise } from "../../../../@whatwg-node/promise-helpers/esm/index.js";
+import { isContentTypeMatch } from "./utils.js";
+import { createGraphQLError } from "../../../../@graphql-tools/utils/esm/errors.js";
+function isPOSTMultipartRequest(request) {
+  return request.method === "POST" && isContentTypeMatch(request, "multipart/form-data");
+}
+function parsePOSTMultipartRequest(request) {
+  return handleMaybePromise(() => request.formData(), (requestBody) => {
+    const operationsStr = requestBody.get("operations");
+    if (!operationsStr) {
+      throw createGraphQLError('Missing multipart form field "operations"');
+    }
+    if (typeof operationsStr !== "string") {
+      throw createGraphQLError('Multipart form field "operations" must be a string');
+    }
+    let operations;
+    try {
+      operations = JSON.parse(operationsStr);
+    } catch {
+      throw createGraphQLError('Multipart form field "operations" must be a valid JSON string');
+    }
+    const mapStr = requestBody.get("map");
+    if (mapStr != null) {
+      if (typeof mapStr !== "string") {
+        throw createGraphQLError('Multipart form field "map" must be a string');
+      }
+      let map;
+      try {
+        map = JSON.parse(mapStr);
+      } catch {
+        throw createGraphQLError('Multipart form field "map" must be a valid JSON string');
+      }
+      for (const fileIndex in map) {
+        const file = requestBody.get(fileIndex);
+        const keys = map[fileIndex];
+        for (const key of keys) {
+          setObjectKeyPath(operations, key, file);
+        }
+      }
+    }
+    return operations;
+  }, (e) => {
+    if (e instanceof Error && e.message.startsWith("File size limit exceeded: ")) {
+      throw createGraphQLError(e.message, {
+        extensions: {
+          http: {
+            status: 413
+          }
+        }
+      });
+    }
+    throw e;
+  });
+}
+function setObjectKeyPath(object, keyPath, value) {
+  const keys = keyPath.split(".");
+  let current = object;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return;
+    }
+    const isLastKey = i === keys.length - 1;
+    if (isLastKey) {
+      current[key] = value;
+    } else {
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+  }
+}
+export {
+  isPOSTMultipartRequest,
+  parsePOSTMultipartRequest
+};
+//# sourceMappingURL=post-multipart.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"post-multipart.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/request-parser/post-multipart.js"],"sourcesContent":["import { createGraphQLError } from '@graphql-tools/utils';\nimport { handleMaybePromise } from '@whatwg-node/promise-helpers';\nimport { isContentTypeMatch } from './utils.js';\nexport function isPOSTMultipartRequest(request) {\n    return request.method === 'POST' && isContentTypeMatch(request, 'multipart/form-data');\n}\nexport function parsePOSTMultipartRequest(request) {\n    return handleMaybePromise(() => request.formData(), (requestBody) => {\n        const operationsStr = requestBody.get('operations');\n        if (!operationsStr) {\n            throw createGraphQLError('Missing multipart form field \"operations\"');\n        }\n        if (typeof operationsStr !== 'string') {\n            throw createGraphQLError('Multipart form field \"operations\" must be a string');\n        }\n        let operations;\n        try {\n            operations = JSON.parse(operationsStr);\n        }\n        catch {\n            throw createGraphQLError('Multipart form field \"operations\" must be a valid JSON string');\n        }\n        const mapStr = requestBody.get('map');\n        if (mapStr != null) {\n            if (typeof mapStr !== 'string') {\n                throw createGraphQLError('Multipart form field \"map\" must be a string');\n            }\n            let map;\n            try {\n                map = JSON.parse(mapStr);\n            }\n            catch {\n                throw createGraphQLError('Multipart form field \"map\" must be a valid JSON string');\n            }\n            for (const fileIndex in map) {\n                const file = requestBody.get(fileIndex);\n                const keys = map[fileIndex];\n                for (const key of keys) {\n                    setObjectKeyPath(operations, key, file);\n                }\n            }\n        }\n        return operations;\n    }, e => {\n        if (e instanceof Error && e.message.startsWith('File size limit exceeded: ')) {\n            throw createGraphQLError(e.message, {\n                extensions: {\n                    http: {\n                        status: 413,\n                    },\n                },\n            });\n        }\n        throw e;\n    });\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction setObjectKeyPath(object, keyPath, value) {\n    const keys = keyPath.split('.');\n    let current = object;\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n            return;\n        }\n        const isLastKey = i === keys.length - 1;\n        if (isLastKey) {\n            current[key] = value;\n        }\n        else {\n            if (!(key in current)) {\n                current[key] = {};\n            }\n            current = current[key];\n        }\n    }\n}\n"],"names":[],"mappings":";;;AAGO,SAAS,uBAAuB,SAAS;AAC5C,SAAO,QAAQ,WAAW,UAAU,mBAAmB,SAAS,qBAAqB;AACzF;AACO,SAAS,0BAA0B,SAAS;AAC/C,SAAO,mBAAmB,MAAM,QAAQ,SAAQ,GAAI,CAAC,gBAAgB;AACjE,UAAM,gBAAgB,YAAY,IAAI,YAAY;AAClD,QAAI,CAAC,eAAe;AAChB,YAAM,mBAAmB,2CAA2C;AAAA,IACxE;AACA,QAAI,OAAO,kBAAkB,UAAU;AACnC,YAAM,mBAAmB,oDAAoD;AAAA,IACjF;AACA,QAAI;AACJ,QAAI;AACA,mBAAa,KAAK,MAAM,aAAa;AAAA,IACzC,QACM;AACF,YAAM,mBAAmB,+DAA+D;AAAA,IAC5F;AACA,UAAM,SAAS,YAAY,IAAI,KAAK;AACpC,QAAI,UAAU,MAAM;AAChB,UAAI,OAAO,WAAW,UAAU;AAC5B,cAAM,mBAAmB,6CAA6C;AAAA,MAC1E;AACA,UAAI;AACJ,UAAI;AACA,cAAM,KAAK,MAAM,MAAM;AAAA,MAC3B,QACM;AACF,cAAM,mBAAmB,wDAAwD;AAAA,MACrF;AACA,iBAAW,aAAa,KAAK;AACzB,cAAM,OAAO,YAAY,IAAI,SAAS;AACtC,cAAM,OAAO,IAAI,SAAS;AAC1B,mBAAW,OAAO,MAAM;AACpB,2BAAiB,YAAY,KAAK,IAAI;AAAA,QAC1C;AAAA,MACJ;AAAA,IACJ;AACA,WAAO;AAAA,EACX,GAAG,OAAK;AACJ,QAAI,aAAa,SAAS,EAAE,QAAQ,WAAW,4BAA4B,GAAG;AAC1E,YAAM,mBAAmB,EAAE,SAAS;AAAA,QAChC,YAAY;AAAA,UACR,MAAM;AAAA,YACF,QAAQ;AAAA,UAChC;AAAA,QACA;AAAA,MACA,CAAa;AAAA,IACL;AACA,UAAM;AAAA,EACV,CAAC;AACL;AAEA,SAAS,iBAAiB,QAAQ,SAAS,OAAO;AAC9C,QAAM,OAAO,QAAQ,MAAM,GAAG;AAC9B,MAAI,UAAU;AACd,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AAClC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ,aAAa;AACrE;AAAA,IACJ;AACA,UAAM,YAAY,MAAM,KAAK,SAAS;AACtC,QAAI,WAAW;AACX,cAAQ,GAAG,IAAI;AAAA,IACnB,OACK;AACD,UAAI,EAAE,OAAO,UAAU;AACnB,gBAAQ,GAAG,IAAI,CAAA;AAAA,MACnB;AACA,gBAAU,QAAQ,GAAG;AAAA,IACzB;AAAA,EACJ;AACJ;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,28 @@
+import { g as globalPonyfillExports } from "../../../../../_virtual/global-ponyfill.js";
+function handleURLSearchParams(searchParams) {
+  const operationName = searchParams.get("operationName") || void 0;
+  const query = searchParams.get("query") || void 0;
+  const variablesStr = searchParams.get("variables") || void 0;
+  const extensionsStr = searchParams.get("extensions") || void 0;
+  return {
+    operationName,
+    query,
+    variables: variablesStr ? JSON.parse(variablesStr) : void 0,
+    extensions: extensionsStr ? JSON.parse(extensionsStr) : void 0
+  };
+}
+function parseURLSearchParams(requestBody) {
+  const searchParams = new globalPonyfillExports.URLSearchParams(requestBody);
+  return handleURLSearchParams(searchParams);
+}
+function isContentTypeMatch(request, expectedContentType) {
+  let contentType = request.headers.get("content-type");
+  contentType = contentType?.split(",")[0] || null;
+  return contentType === expectedContentType || !!contentType?.startsWith(`${expectedContentType};`);
+}
+export {
+  handleURLSearchParams,
+  isContentTypeMatch,
+  parseURLSearchParams
+};
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/request-parser/utils.js"],"sourcesContent":["import { URLSearchParams } from '@whatwg-node/fetch';\nexport function handleURLSearchParams(searchParams) {\n    const operationName = searchParams.get('operationName') || undefined;\n    const query = searchParams.get('query') || undefined;\n    const variablesStr = searchParams.get('variables') || undefined;\n    const extensionsStr = searchParams.get('extensions') || undefined;\n    return {\n        operationName,\n        query,\n        variables: variablesStr ? JSON.parse(variablesStr) : undefined,\n        extensions: extensionsStr ? JSON.parse(extensionsStr) : undefined,\n    };\n}\nexport function parseURLSearchParams(requestBody) {\n    const searchParams = new URLSearchParams(requestBody);\n    return handleURLSearchParams(searchParams);\n}\nexport function isContentTypeMatch(request, expectedContentType) {\n    let contentType = request.headers.get('content-type');\n    // a list of content-types is not valid as per HTTP spec, but some clients dont care\n    contentType = contentType?.split(',')[0] || null;\n    return (contentType === expectedContentType || !!contentType?.startsWith(`${expectedContentType};`));\n}\n"],"names":["URLSearchParams"],"mappings":";AACO,SAAS,sBAAsB,cAAc;AAChD,QAAM,gBAAgB,aAAa,IAAI,eAAe,KAAK;AAC3D,QAAM,QAAQ,aAAa,IAAI,OAAO,KAAK;AAC3C,QAAM,eAAe,aAAa,IAAI,WAAW,KAAK;AACtD,QAAM,gBAAgB,aAAa,IAAI,YAAY,KAAK;AACxD,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA,WAAW,eAAe,KAAK,MAAM,YAAY,IAAI;AAAA,IACrD,YAAY,gBAAgB,KAAK,MAAM,aAAa,IAAI;AAAA,EAChE;AACA;AACO,SAAS,qBAAqB,aAAa;AAC9C,QAAM,eAAe,IAAIA,sBAAAA,gBAAgB,WAAW;AACpD,SAAO,sBAAsB,YAAY;AAC7C;AACO,SAAS,mBAAmB,SAAS,qBAAqB;AAC7D,MAAI,cAAc,QAAQ,QAAQ,IAAI,cAAc;AAEpD,gBAAc,aAAa,MAAM,GAAG,EAAE,CAAC,KAAK;AAC5C,SAAQ,gBAAgB,uBAAuB,CAAC,CAAC,aAAa,WAAW,GAAG,mBAAmB,GAAG;AACtG;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-check-graphql-query-params.js

@@ -0,0 +1,131 @@
+import { createGraphQLError } from "../../../../@graphql-tools/utils/esm/errors.js";
+const expectedParameters = /* @__PURE__ */ new Set(["query", "variables", "operationName", "extensions"]);
+function assertInvalidParams(params, extraParamNames) {
+  if (params == null || typeof params !== "object") {
+    throw createGraphQLError('Invalid "params" in the request body', {
+      extensions: {
+        http: {
+          spec: true,
+          status: 400
+        },
+        code: "BAD_REQUEST"
+      }
+    });
+  }
+  for (const paramKey in params) {
+    if (params[paramKey] == null) {
+      continue;
+    }
+    if (!expectedParameters.has(paramKey)) {
+      if (extraParamNames?.includes(paramKey)) {
+        continue;
+      }
+      throw createGraphQLError(`Unexpected parameter "${paramKey}" in the request body.`, {
+        extensions: {
+          http: {
+            status: 400
+          },
+          code: "BAD_REQUEST"
+        }
+      });
+    }
+  }
+}
+function checkGraphQLQueryParams(params, extraParamNames) {
+  if (!isObject(params)) {
+    throw createGraphQLError(`Expected params to be an object but given ${extendedTypeof(params)}.`, {
+      extensions: {
+        http: {
+          status: 400,
+          headers: {
+            Allow: "GET, POST"
+          }
+        },
+        code: "BAD_REQUEST"
+      }
+    });
+  }
+  assertInvalidParams(params, extraParamNames);
+  if (params["query"] == null) {
+    throw createGraphQLError("Must provide query string.", {
+      extensions: {
+        http: {
+          spec: true,
+          status: 400,
+          headers: {
+            Allow: "GET, POST"
+          }
+        },
+        code: "BAD_REQUEST"
+      }
+    });
+  }
+  const queryType = extendedTypeof(params["query"]);
+  if (queryType !== "string") {
+    throw createGraphQLError(`Expected "query" param to be a string, but given ${queryType}.`, {
+      extensions: {
+        http: {
+          status: 400,
+          headers: {
+            Allow: "GET, POST"
+          }
+        },
+        code: "BAD_REQUEST"
+      }
+    });
+  }
+  const variablesParamType = extendedTypeof(params["variables"]);
+  if (!["object", "null", "undefined"].includes(variablesParamType)) {
+    throw createGraphQLError(`Expected "variables" param to be empty or an object, but given ${variablesParamType}.`, {
+      extensions: {
+        http: {
+          status: 400,
+          headers: {
+            Allow: "GET, POST"
+          }
+        },
+        code: "BAD_REQUEST"
+      }
+    });
+  }
+  const extensionsParamType = extendedTypeof(params["extensions"]);
+  if (!["object", "null", "undefined"].includes(extensionsParamType)) {
+    throw createGraphQLError(`Expected "extensions" param to be empty or an object, but given ${extensionsParamType}.`, {
+      extensions: {
+        http: {
+          status: 400,
+          headers: {
+            Allow: "GET, POST"
+          }
+        },
+        code: "BAD_REQUEST"
+      }
+    });
+  }
+  return params;
+}
+function useCheckGraphQLQueryParams(extraParamNames) {
+  return {
+    onParams({ params }) {
+      checkGraphQLQueryParams(params, extraParamNames);
+    }
+  };
+}
+function extendedTypeof(val) {
+  if (val === null) {
+    return "null";
+  }
+  if (Array.isArray(val)) {
+    return "array";
+  }
+  return typeof val;
+}
+function isObject(val) {
+  return extendedTypeof(val) === "object";
+}
+export {
+  assertInvalidParams,
+  checkGraphQLQueryParams,
+  useCheckGraphQLQueryParams
+};
+//# sourceMappingURL=use-check-graphql-query-params.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-check-graphql-query-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-check-graphql-query-params.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/request-validation/use-check-graphql-query-params.js"],"sourcesContent":["import { createGraphQLError } from '@graphql-tools/utils';\nconst expectedParameters = new Set(['query', 'variables', 'operationName', 'extensions']);\nexport function assertInvalidParams(params, extraParamNames) {\n    if (params == null || typeof params !== 'object') {\n        throw createGraphQLError('Invalid \"params\" in the request body', {\n            extensions: {\n                http: {\n                    spec: true,\n                    status: 400,\n                },\n                code: 'BAD_REQUEST',\n            },\n        });\n    }\n    for (const paramKey in params) {\n        if (params[paramKey] == null) {\n            continue;\n        }\n        if (!expectedParameters.has(paramKey)) {\n            if (extraParamNames?.includes(paramKey)) {\n                continue;\n            }\n            throw createGraphQLError(`Unexpected parameter \"${paramKey}\" in the request body.`, {\n                extensions: {\n                    http: {\n                        status: 400,\n                    },\n                    code: 'BAD_REQUEST',\n                },\n            });\n        }\n    }\n}\nexport function checkGraphQLQueryParams(params, extraParamNames) {\n    if (!isObject(params)) {\n        throw createGraphQLError(`Expected params to be an object but given ${extendedTypeof(params)}.`, {\n            extensions: {\n                http: {\n                    status: 400,\n                    headers: {\n                        Allow: 'GET, POST',\n                    },\n                },\n                code: 'BAD_REQUEST',\n            },\n        });\n    }\n    assertInvalidParams(params, extraParamNames);\n    if (params['query'] == null) {\n        throw createGraphQLError('Must provide query string.', {\n            extensions: {\n                http: {\n                    spec: true,\n                    status: 400,\n                    headers: {\n                        Allow: 'GET, POST',\n                    },\n                },\n                code: 'BAD_REQUEST',\n            },\n        });\n    }\n    const queryType = extendedTypeof(params['query']);\n    if (queryType !== 'string') {\n        throw createGraphQLError(`Expected \"query\" param to be a string, but given ${queryType}.`, {\n            extensions: {\n                http: {\n                    status: 400,\n                    headers: {\n                        Allow: 'GET, POST',\n                    },\n                },\n                code: 'BAD_REQUEST',\n            },\n        });\n    }\n    const variablesParamType = extendedTypeof(params['variables']);\n    if (!['object', 'null', 'undefined'].includes(variablesParamType)) {\n        throw createGraphQLError(`Expected \"variables\" param to be empty or an object, but given ${variablesParamType}.`, {\n            extensions: {\n                http: {\n                    status: 400,\n                    headers: {\n                        Allow: 'GET, POST',\n                    },\n                },\n                code: 'BAD_REQUEST',\n            },\n        });\n    }\n    const extensionsParamType = extendedTypeof(params['extensions']);\n    if (!['object', 'null', 'undefined'].includes(extensionsParamType)) {\n        throw createGraphQLError(`Expected \"extensions\" param to be empty or an object, but given ${extensionsParamType}.`, {\n            extensions: {\n                http: {\n                    status: 400,\n                    headers: {\n                        Allow: 'GET, POST',\n                    },\n                },\n                code: 'BAD_REQUEST',\n            },\n        });\n    }\n    return params;\n}\nexport function isValidGraphQLParams(params) {\n    try {\n        checkGraphQLQueryParams(params);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\nexport function useCheckGraphQLQueryParams(extraParamNames) {\n    return {\n        onParams({ params }) {\n            checkGraphQLQueryParams(params, extraParamNames);\n        },\n    };\n}\nfunction extendedTypeof(val) {\n    if (val === null) {\n        return 'null';\n    }\n    if (Array.isArray(val)) {\n        return 'array';\n    }\n    return typeof val;\n}\nfunction isObject(val) {\n    return extendedTypeof(val) === 'object';\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-check-method-for-graphql.js

@@ -0,0 +1,28 @@
+import { createGraphQLError } from "../../../../@graphql-tools/utils/esm/errors.js";
+function isValidMethodForGraphQL(method) {
+  return method === "GET" || method === "POST";
+}
+function useCheckMethodForGraphQL() {
+  return {
+    onRequestParse({ request }) {
+      if (!isValidMethodForGraphQL(request.method)) {
+        throw createGraphQLError("GraphQL only supports GET and POST requests.", {
+          extensions: {
+            http: {
+              status: 405,
+              headers: {
+                Allow: "GET, POST"
+              }
+            },
+            code: "BAD_REQUEST"
+          }
+        });
+      }
+    }
+  };
+}
+export {
+  isValidMethodForGraphQL,
+  useCheckMethodForGraphQL
+};
+//# sourceMappingURL=use-check-method-for-graphql.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-check-method-for-graphql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-check-method-for-graphql.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/request-validation/use-check-method-for-graphql.js"],"sourcesContent":["import { createGraphQLError } from '@graphql-tools/utils';\nexport function isValidMethodForGraphQL(method) {\n    return method === 'GET' || method === 'POST';\n}\nexport function useCheckMethodForGraphQL() {\n    return {\n        onRequestParse({ request }) {\n            if (!isValidMethodForGraphQL(request.method)) {\n                throw createGraphQLError('GraphQL only supports GET and POST requests.', {\n                    extensions: {\n                        http: {\n                            status: 405,\n                            headers: {\n                                Allow: 'GET, POST',\n                            },\n                        },\n                        code: 'BAD_REQUEST',\n                    },\n                });\n            }\n        },\n    };\n}\n"],"names":[],"mappings":";AACO,SAAS,wBAAwB,QAAQ;AAC5C,SAAO,WAAW,SAAS,WAAW;AAC1C;AACO,SAAS,2BAA2B;AACvC,SAAO;AAAA,IACH,eAAe,EAAE,WAAW;AACxB,UAAI,CAAC,wBAAwB,QAAQ,MAAM,GAAG;AAC1C,cAAM,mBAAmB,gDAAgD;AAAA,UACrE,YAAY;AAAA,YACR,MAAM;AAAA,cACF,QAAQ;AAAA,cACR,SAAS;AAAA,gBACL,OAAO;AAAA,cACvC;AAAA,YACA;AAAA,YACwB,MAAM;AAAA,UAC9B;AAAA,QACA,CAAiB;AAAA,MACL;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-http-validation-error.js

@@ -0,0 +1,21 @@
+function useHTTPValidationError() {
+  return {
+    onValidate() {
+      return ({ valid, result }) => {
+        if (!valid) {
+          for (const error of result) {
+            error.extensions ||= {};
+            error.extensions.code ||= "GRAPHQL_VALIDATION_FAILED";
+            error.extensions.http ||= {};
+            error.extensions.http.spec = error.extensions.http.spec == null ? true : error.extensions.http.spec;
+            error.extensions.http.status ||= 400;
+          }
+        }
+      };
+    }
+  };
+}
+export {
+  useHTTPValidationError
+};
+//# sourceMappingURL=use-http-validation-error.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-http-validation-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-http-validation-error.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/request-validation/use-http-validation-error.js"],"sourcesContent":["export function useHTTPValidationError() {\n    return {\n        onValidate() {\n            return ({ valid, result }) => {\n                if (!valid) {\n                    for (const error of result) {\n                        error.extensions ||= {};\n                        error.extensions.code ||= 'GRAPHQL_VALIDATION_FAILED';\n                        error.extensions.http ||= {};\n                        error.extensions.http.spec =\n                            error.extensions.http.spec == null ? true : error.extensions.http.spec;\n                        error.extensions.http.status ||= 400;\n                    }\n                }\n            };\n        },\n    };\n}\n"],"names":[],"mappings":"AAAO,SAAS,yBAAyB;AACrC,SAAO;AAAA,IACH,aAAa;AACT,aAAO,CAAC,EAAE,OAAO,aAAa;AAC1B,YAAI,CAAC,OAAO;AACR,qBAAW,SAAS,QAAQ;AACxB,kBAAM,eAAe,CAAA;AACrB,kBAAM,WAAW,SAAS;AAC1B,kBAAM,WAAW,SAAS,CAAA;AAC1B,kBAAM,WAAW,KAAK,OAClB,MAAM,WAAW,KAAK,QAAQ,OAAO,OAAO,MAAM,WAAW,KAAK;AACtE,kBAAM,WAAW,KAAK,WAAW;AAAA,UACrC;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-limit-batching.js

@@ -0,0 +1,37 @@
+import { createGraphQLError } from "../../../../@graphql-tools/utils/esm/errors.js";
+function useLimitBatching(limit) {
+  return {
+    onRequestParse() {
+      return {
+        onRequestParseDone({ requestParserResult }) {
+          if (Array.isArray(requestParserResult)) {
+            if (!limit) {
+              throw createGraphQLError(`Batching is not supported.`, {
+                extensions: {
+                  http: {
+                    status: 400
+                  },
+                  code: "BAD_REQUEST"
+                }
+              });
+            }
+            if (requestParserResult.length > limit) {
+              throw createGraphQLError(`Batching is limited to ${limit} operations per request.`, {
+                extensions: {
+                  http: {
+                    status: 413
+                  },
+                  code: "BAD_REQUEST"
+                }
+              });
+            }
+          }
+        }
+      };
+    }
+  };
+}
+export {
+  useLimitBatching
+};
+//# sourceMappingURL=use-limit-batching.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-limit-batching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-limit-batching.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/request-validation/use-limit-batching.js"],"sourcesContent":["import { createGraphQLError } from '@graphql-tools/utils';\nexport function useLimitBatching(limit) {\n    return {\n        onRequestParse() {\n            return {\n                onRequestParseDone({ requestParserResult }) {\n                    if (Array.isArray(requestParserResult)) {\n                        if (!limit) {\n                            throw createGraphQLError(`Batching is not supported.`, {\n                                extensions: {\n                                    http: {\n                                        status: 400,\n                                    },\n                                    code: 'BAD_REQUEST',\n                                },\n                            });\n                        }\n                        if (requestParserResult.length > limit) {\n                            throw createGraphQLError(`Batching is limited to ${limit} operations per request.`, {\n                                extensions: {\n                                    http: {\n                                        status: 413,\n                                    },\n                                    code: 'BAD_REQUEST',\n                                },\n                            });\n                        }\n                    }\n                },\n            };\n        },\n    };\n}\n"],"names":[],"mappings":";AACO,SAAS,iBAAiB,OAAO;AACpC,SAAO;AAAA,IACH,iBAAiB;AACb,aAAO;AAAA,QACH,mBAAmB,EAAE,uBAAuB;AACxC,cAAI,MAAM,QAAQ,mBAAmB,GAAG;AACpC,gBAAI,CAAC,OAAO;AACR,oBAAM,mBAAmB,8BAA8B;AAAA,gBACnD,YAAY;AAAA,kBACR,MAAM;AAAA,oBACF,QAAQ;AAAA,kBAChD;AAAA,kBACoC,MAAM;AAAA,gBAC1C;AAAA,cACA,CAA6B;AAAA,YACL;AACA,gBAAI,oBAAoB,SAAS,OAAO;AACpC,oBAAM,mBAAmB,0BAA0B,KAAK,4BAA4B;AAAA,gBAChF,YAAY;AAAA,kBACR,MAAM;AAAA,oBACF,QAAQ;AAAA,kBAChD;AAAA,kBACoC,MAAM;AAAA,gBAC1C;AAAA,cACA,CAA6B;AAAA,YACL;AAAA,UACJ;AAAA,QACJ;AAAA,MAChB;AAAA,IACQ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-prevent-mutation-via-get.js

@@ -0,0 +1,61 @@
+import { GraphQLError } from "../../../../graphql/error/GraphQLError.js";
+import { getOperationAST } from "../../../../graphql/utilities/getOperationAST.js";
+import { createGraphQLError } from "../../../../@graphql-tools/utils/esm/errors.js";
+function assertMutationViaGet(method, document, operationName) {
+  const operation = document ? getOperationAST(document, operationName) ?? void 0 : void 0;
+  if (!operation) {
+    throw createGraphQLError("Could not determine what operation to execute.", {
+      extensions: {
+        code: "OPERATION_RESOLUTION_FAILURE",
+        http: {
+          status: 400
+        }
+      }
+    });
+  }
+  if (operation.operation === "mutation" && method === "GET") {
+    throw createGraphQLError("Can only perform a mutation operation from a POST request.", {
+      extensions: {
+        http: {
+          status: 405,
+          headers: {
+            Allow: "POST"
+          }
+        },
+        code: "BAD_REQUEST"
+      }
+    });
+  }
+}
+function usePreventMutationViaGET() {
+  return {
+    onParse() {
+      return ({ result, context: {
+        request,
+        // the `params` might be missing in cases where the user provided
+        // malformed context to getEnveloped (like `yoga.getEnveloped({})`)
+        params: { operationName } = {}
+      } }) => {
+        if (!request) {
+          return;
+        }
+        if (result instanceof Error) {
+          if (result instanceof GraphQLError) {
+            const extensions = result.extensions ||= {};
+            extensions["code"] ||= "GRAPHQL_PARSE_FAILED";
+            const httpExtensions = extensions["http"] ||= {};
+            httpExtensions.spec ||= true;
+            httpExtensions.status ||= 400;
+          }
+        } else {
+          assertMutationViaGet(request.method, result, operationName);
+        }
+      };
+    }
+  };
+}
+export {
+  assertMutationViaGet,
+  usePreventMutationViaGET
+};
+//# sourceMappingURL=use-prevent-mutation-via-get.js.map

package/dist/node_modules/graphql-yoga/esm/plugins/request-validation/use-prevent-mutation-via-get.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-prevent-mutation-via-get.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/request-validation/use-prevent-mutation-via-get.js"],"sourcesContent":["import { getOperationAST, GraphQLError, } from 'graphql';\nimport { createGraphQLError } from '@graphql-tools/utils';\nexport function assertMutationViaGet(method, document, operationName) {\n    const operation = document\n        ? (getOperationAST(document, operationName) ?? undefined)\n        : undefined;\n    if (!operation) {\n        throw createGraphQLError('Could not determine what operation to execute.', {\n            extensions: {\n                code: 'OPERATION_RESOLUTION_FAILURE',\n                http: {\n                    status: 400,\n                },\n            },\n        });\n    }\n    if (operation.operation === 'mutation' && method === 'GET') {\n        throw createGraphQLError('Can only perform a mutation operation from a POST request.', {\n            extensions: {\n                http: {\n                    status: 405,\n                    headers: {\n                        Allow: 'POST',\n                    },\n                },\n                code: 'BAD_REQUEST',\n            },\n        });\n    }\n}\nexport function usePreventMutationViaGET() {\n    return {\n        onParse() {\n            // We should improve this by getting Yoga stuff from the hook params directly instead of the context\n            return ({ result, context: { request, \n            // the `params` might be missing in cases where the user provided\n            // malformed context to getEnveloped (like `yoga.getEnveloped({})`)\n            params: { operationName } = {}, }, }) => {\n                // Run only if this is a Yoga request\n                // the `request` might be missing when using graphql-ws for example\n                // in which case throwing an error would abruptly close the socket\n                if (!request) {\n                    return;\n                }\n                if (result instanceof Error) {\n                    if (result instanceof GraphQLError) {\n                        // @ts-expect-error - We are modifying the extensions on purpose\n                        const extensions = (result.extensions ||= {});\n                        extensions['code'] ||= 'GRAPHQL_PARSE_FAILED';\n                        const httpExtensions = (extensions['http'] ||= {});\n                        httpExtensions.spec ||= true;\n                        httpExtensions.status ||= 400;\n                    }\n                }\n                else {\n                    assertMutationViaGet(request.method, result, operationName);\n                }\n            };\n        },\n    };\n}\n"],"names":[],"mappings":";;;AAEO,SAAS,qBAAqB,QAAQ,UAAU,eAAe;AAClE,QAAM,YAAY,WACX,gBAAgB,UAAU,aAAa,KAAK,SAC7C;AACN,MAAI,CAAC,WAAW;AACZ,UAAM,mBAAmB,kDAAkD;AAAA,MACvE,YAAY;AAAA,QACR,MAAM;AAAA,QACN,MAAM;AAAA,UACF,QAAQ;AAAA,QAC5B;AAAA,MACA;AAAA,IACA,CAAS;AAAA,EACL;AACA,MAAI,UAAU,cAAc,cAAc,WAAW,OAAO;AACxD,UAAM,mBAAmB,8DAA8D;AAAA,MACnF,YAAY;AAAA,QACR,MAAM;AAAA,UACF,QAAQ;AAAA,UACR,SAAS;AAAA,YACL,OAAO;AAAA,UAC/B;AAAA,QACA;AAAA,QACgB,MAAM;AAAA,MACtB;AAAA,IACA,CAAS;AAAA,EACL;AACJ;AACO,SAAS,2BAA2B;AACvC,SAAO;AAAA,IACH,UAAU;AAEN,aAAO,CAAC,EAAE,QAAQ,SAAS;AAAA,QAAE;AAAA;AAAA;AAAA,QAG7B,QAAQ,EAAE,kBAAkB,CAAA;AAAA,MAAE,EAAG,MAAQ;AAIrC,YAAI,CAAC,SAAS;AACV;AAAA,QACJ;AACA,YAAI,kBAAkB,OAAO;AACzB,cAAI,kBAAkB,cAAc;AAEhC,kBAAM,aAAc,OAAO,eAAe;AAC1C,uBAAW,MAAM,MAAM;AACvB,kBAAM,iBAAkB,WAAW,MAAM,MAAM,CAAA;AAC/C,2BAAe,SAAS;AACxB,2BAAe,WAAW;AAAA,UAC9B;AAAA,QACJ,OACK;AACD,+BAAqB,QAAQ,QAAQ,QAAQ,aAAa;AAAA,QAC9D;AAAA,MACJ;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,28 @@
+function getMediaTypesForRequestInOrder(request) {
+  const accepts = (request.headers.get("accept") || "*/*").replace(/\s/g, "").toLowerCase().split(",");
+  const mediaTypes = [];
+  for (const accept of accepts) {
+    const [mediaType, ...params] = accept.split(";");
+    if (mediaType === void 0)
+      continue;
+    const charset = params?.find((param) => param.includes("charset=")) || "charset=utf-8";
+    if (charset !== "charset=utf-8") {
+      continue;
+    }
+    mediaTypes.push(mediaType);
+  }
+  return mediaTypes.reverse();
+}
+function isMatchingMediaType(askedMediaType, processorMediaType) {
+  const [askedPre, askedSuf] = askedMediaType.split("/");
+  const [pre, suf] = processorMediaType.split("/");
+  if ((pre === "*" || pre === askedPre) && (suf === "*" || suf === askedSuf)) {
+    return true;
+  }
+  return false;
+}
+export {
+  getMediaTypesForRequestInOrder,
+  isMatchingMediaType
+};
+//# sourceMappingURL=accept.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accept.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/result-processor/accept.js"],"sourcesContent":["export function getMediaTypesForRequestInOrder(request) {\n    const accepts = (request.headers.get('accept') || '*/*')\n        .replace(/\\s/g, '')\n        .toLowerCase()\n        .split(',');\n    const mediaTypes = [];\n    for (const accept of accepts) {\n        const [mediaType, ...params] = accept.split(';');\n        if (mediaType === undefined)\n            continue; // If true, malformed header.\n        const charset = params?.find(param => param.includes('charset=')) || 'charset=utf-8'; // utf-8 is assumed when not specified;\n        if (charset !== 'charset=utf-8') {\n            // only utf-8 is supported\n            continue;\n        }\n        mediaTypes.push(mediaType);\n    }\n    return mediaTypes.reverse();\n}\nexport function isMatchingMediaType(askedMediaType, processorMediaType) {\n    const [askedPre, askedSuf] = askedMediaType.split('/');\n    const [pre, suf] = processorMediaType.split('/');\n    if ((pre === '*' || pre === askedPre) && (suf === '*' || suf === askedSuf)) {\n        return true;\n    }\n    return false;\n}\n"],"names":[],"mappings":"AAAO,SAAS,+BAA+B,SAAS;AACpD,QAAM,WAAW,QAAQ,QAAQ,IAAI,QAAQ,KAAK,OAC7C,QAAQ,OAAO,EAAE,EACjB,YAAW,EACX,MAAM,GAAG;AACd,QAAM,aAAa,CAAA;AACnB,aAAW,UAAU,SAAS;AAC1B,UAAM,CAAC,WAAW,GAAG,MAAM,IAAI,OAAO,MAAM,GAAG;AAC/C,QAAI,cAAc;AACd;AACJ,UAAM,UAAU,QAAQ,KAAK,WAAS,MAAM,SAAS,UAAU,CAAC,KAAK;AACrE,QAAI,YAAY,iBAAiB;AAE7B;AAAA,IACJ;AACA,eAAW,KAAK,SAAS;AAAA,EAC7B;AACA,SAAO,WAAW,QAAO;AAC7B;AACO,SAAS,oBAAoB,gBAAgB,oBAAoB;AACpE,QAAM,CAAC,UAAU,QAAQ,IAAI,eAAe,MAAM,GAAG;AACrD,QAAM,CAAC,KAAK,GAAG,IAAI,mBAAmB,MAAM,GAAG;AAC/C,OAAK,QAAQ,OAAO,QAAQ,cAAc,QAAQ,OAAO,QAAQ,WAAW;AACxE,WAAO;AAAA,EACX;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,68 @@
+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 processMultipartResult(result, fetchAPI) {
+  const headersInit = {
+    Connection: "keep-alive",
+    "Content-Type": 'multipart/mixed; boundary="-"',
+    "Transfer-Encoding": "chunked"
+  };
+  const responseInit = getResponseInitByRespectingErrors(result, headersInit);
+  let iterator;
+  const textEncoder = new fetchAPI.TextEncoder();
+  const readableStream = new fetchAPI.ReadableStream({
+    start(controller) {
+      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 });
+          }
+        };
+      }
+      controller.enqueue(textEncoder.encode("\r\n"));
+      controller.enqueue(textEncoder.encode(`---`));
+    },
+    pull(controller) {
+      return handleMaybePromise(() => iterator.next(), ({ done, value }) => {
+        if (value != null) {
+          controller.enqueue(textEncoder.encode("\r\n"));
+          controller.enqueue(textEncoder.encode("Content-Type: application/json; charset=utf-8"));
+          controller.enqueue(textEncoder.encode("\r\n"));
+          const chunk = jsonStringifyResultWithoutInternals(value);
+          const encodedChunk = textEncoder.encode(chunk);
+          controller.enqueue(textEncoder.encode("Content-Length: " + encodedChunk.byteLength));
+          controller.enqueue(textEncoder.encode("\r\n"));
+          controller.enqueue(textEncoder.encode("\r\n"));
+          controller.enqueue(encodedChunk);
+          controller.enqueue(textEncoder.encode("\r\n"));
+          controller.enqueue(textEncoder.encode("---"));
+        }
+        if (done) {
+          controller.enqueue(textEncoder.encode("--\r\n"));
+          controller.close();
+        }
+      }, (err) => {
+        controller.error(err);
+      });
+    },
+    cancel(e) {
+      if (iterator.return) {
+        return handleMaybePromise(() => iterator.return?.(e), () => {
+        });
+      }
+    }
+  });
+  return new fetchAPI.Response(readableStream, responseInit);
+}
+export {
+  processMultipartResult
+};
+//# sourceMappingURL=multipart.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/result-processor/multipart.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 processMultipartResult(result, fetchAPI) {\n    const headersInit = {\n        Connection: 'keep-alive',\n        'Content-Type': 'multipart/mixed; boundary=\"-\"',\n        'Transfer-Encoding': 'chunked',\n    };\n    const responseInit = getResponseInitByRespectingErrors(result, headersInit);\n    let iterator;\n    const textEncoder = new fetchAPI.TextEncoder();\n    const readableStream = new fetchAPI.ReadableStream({\n        start(controller) {\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            controller.enqueue(textEncoder.encode('\\r\\n'));\n            controller.enqueue(textEncoder.encode(`---`));\n        },\n        pull(controller) {\n            return handleMaybePromise(() => iterator.next(), ({ done, value }) => {\n                if (value != null) {\n                    controller.enqueue(textEncoder.encode('\\r\\n'));\n                    controller.enqueue(textEncoder.encode('Content-Type: application/json; charset=utf-8'));\n                    controller.enqueue(textEncoder.encode('\\r\\n'));\n                    const chunk = jsonStringifyResultWithoutInternals(value);\n                    const encodedChunk = textEncoder.encode(chunk);\n                    controller.enqueue(textEncoder.encode('Content-Length: ' + encodedChunk.byteLength));\n                    controller.enqueue(textEncoder.encode('\\r\\n'));\n                    controller.enqueue(textEncoder.encode('\\r\\n'));\n                    controller.enqueue(encodedChunk);\n                    controller.enqueue(textEncoder.encode('\\r\\n'));\n                    controller.enqueue(textEncoder.encode('---'));\n                }\n                if (done) {\n                    controller.enqueue(textEncoder.encode('--\\r\\n'));\n                    controller.close();\n                }\n            }, err => {\n                controller.error(err);\n            });\n        },\n        cancel(e) {\n            if (iterator.return) {\n                return handleMaybePromise(() => iterator.return?.(e), () => { });\n            }\n        },\n    });\n    return new fetchAPI.Response(readableStream, responseInit);\n}\n"],"names":[],"mappings":";;;;AAKO,SAAS,uBAAuB,QAAQ,UAAU;AACrD,QAAM,cAAc;AAAA,IAChB,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,qBAAqB;AAAA,EAC7B;AACI,QAAM,eAAe,kCAAkC,QAAQ,WAAW;AAC1E,MAAI;AACJ,QAAM,cAAc,IAAI,SAAS,YAAW;AAC5C,QAAM,iBAAiB,IAAI,SAAS,eAAe;AAAA,IAC/C,MAAM,YAAY;AACd,UAAI,gBAAgB,MAAM,GAAG;AACzB,mBAAW,OAAO,OAAO,aAAa,EAAC;AAAA,MAC3C,OACK;AACD,YAAI,WAAW;AACf,mBAAW;AAAA,UACP,MAAM,MAAM;AACR,gBAAI,UAAU;AACV,qBAAO,YAAY,EAAE,MAAM,MAAM,OAAO,KAAI,CAAE;AAAA,YAClD;AACA,uBAAW;AACX,mBAAO,YAAY,EAAE,MAAM,OAAO,OAAO,OAAM,CAAE;AAAA,UACrD;AAAA,QACpB;AAAA,MACY;AACA,iBAAW,QAAQ,YAAY,OAAO,MAAM,CAAC;AAC7C,iBAAW,QAAQ,YAAY,OAAO,KAAK,CAAC;AAAA,IAChD;AAAA,IACA,KAAK,YAAY;AACb,aAAO,mBAAmB,MAAM,SAAS,KAAI,GAAI,CAAC,EAAE,MAAM,YAAY;AAClE,YAAI,SAAS,MAAM;AACf,qBAAW,QAAQ,YAAY,OAAO,MAAM,CAAC;AAC7C,qBAAW,QAAQ,YAAY,OAAO,+CAA+C,CAAC;AACtF,qBAAW,QAAQ,YAAY,OAAO,MAAM,CAAC;AAC7C,gBAAM,QAAQ,oCAAoC,KAAK;AACvD,gBAAM,eAAe,YAAY,OAAO,KAAK;AAC7C,qBAAW,QAAQ,YAAY,OAAO,qBAAqB,aAAa,UAAU,CAAC;AACnF,qBAAW,QAAQ,YAAY,OAAO,MAAM,CAAC;AAC7C,qBAAW,QAAQ,YAAY,OAAO,MAAM,CAAC;AAC7C,qBAAW,QAAQ,YAAY;AAC/B,qBAAW,QAAQ,YAAY,OAAO,MAAM,CAAC;AAC7C,qBAAW,QAAQ,YAAY,OAAO,KAAK,CAAC;AAAA,QAChD;AACA,YAAI,MAAM;AACN,qBAAW,QAAQ,YAAY,OAAO,QAAQ,CAAC;AAC/C,qBAAW,MAAK;AAAA,QACpB;AAAA,MACJ,GAAG,SAAO;AACN,mBAAW,MAAM,GAAG;AAAA,MACxB,CAAC;AAAA,IACL;AAAA,IACA,OAAO,GAAG;AACN,UAAI,SAAS,QAAQ;AACjB,eAAO,mBAAmB,MAAM,SAAS,SAAS,CAAC,GAAG,MAAM;AAAA,QAAE,CAAC;AAAA,MACnE;AAAA,IACJ;AAAA,EACR,CAAK;AACD,SAAO,IAAI,SAAS,SAAS,gBAAgB,YAAY;AAC7D;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,29 @@
+import { getResponseInitByRespectingErrors, areGraphQLErrors, isGraphQLError } from "../../error.js";
+import { jsonStringifyResultWithoutInternals } from "./stringify.js";
+import { isAsyncIterable } from "../../../../@graphql-tools/utils/esm/isAsyncIterable.js";
+function processRegularResult(executionResult, fetchAPI, acceptedHeader) {
+  if (isAsyncIterable(executionResult)) {
+    return new fetchAPI.Response(null, {
+      status: 406,
+      statusText: "Not Acceptable",
+      headers: {
+        accept: "application/json; charset=utf-8, application/graphql-response+json; charset=utf-8"
+      }
+    });
+  }
+  const headersInit = {
+    "Content-Type": acceptedHeader + "; charset=utf-8"
+  };
+  const responseInit = getResponseInitByRespectingErrors(
+    executionResult,
+    headersInit,
+    // prefer 200 only if accepting application/json and all errors are exclusively GraphQL errors
+    acceptedHeader === "application/json" && !Array.isArray(executionResult) && areGraphQLErrors(executionResult.errors) && executionResult.errors.some((err) => !err.extensions?.["originalError"] || isGraphQLError(err.extensions["originalError"]))
+  );
+  const responseBody = jsonStringifyResultWithoutInternals(executionResult);
+  return new fetchAPI.Response(responseBody, responseInit);
+}
+export {
+  processRegularResult
+};
+//# sourceMappingURL=regular.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regular.js","sources":["../../../../../../node_modules/graphql-yoga/esm/plugins/result-processor/regular.js"],"sourcesContent":["import { isAsyncIterable } from '@graphql-tools/utils';\nimport { areGraphQLErrors, getResponseInitByRespectingErrors, isGraphQLError, } from '../../error.js';\nimport { jsonStringifyResultWithoutInternals } from './stringify.js';\nexport function processRegularResult(executionResult, fetchAPI, acceptedHeader) {\n    if (isAsyncIterable(executionResult)) {\n        return new fetchAPI.Response(null, {\n            status: 406,\n            statusText: 'Not Acceptable',\n            headers: {\n                accept: 'application/json; charset=utf-8, application/graphql-response+json; charset=utf-8',\n            },\n        });\n    }\n    const headersInit = {\n        'Content-Type': acceptedHeader + '; charset=utf-8',\n    };\n    const responseInit = getResponseInitByRespectingErrors(executionResult, headersInit, \n    // prefer 200 only if accepting application/json and all errors are exclusively GraphQL errors\n    acceptedHeader === 'application/json' &&\n        !Array.isArray(executionResult) &&\n        areGraphQLErrors(executionResult.errors) &&\n        executionResult.errors.some(err => !err.extensions?.['originalError'] || isGraphQLError(err.extensions['originalError'])));\n    const responseBody = jsonStringifyResultWithoutInternals(executionResult);\n    return new fetchAPI.Response(responseBody, responseInit);\n}\n"],"names":[],"mappings":";;;AAGO,SAAS,qBAAqB,iBAAiB,UAAU,gBAAgB;AAC5E,MAAI,gBAAgB,eAAe,GAAG;AAClC,WAAO,IAAI,SAAS,SAAS,MAAM;AAAA,MAC/B,QAAQ;AAAA,MACR,YAAY;AAAA,MACZ,SAAS;AAAA,QACL,QAAQ;AAAA,MACxB;AAAA,IACA,CAAS;AAAA,EACL;AACA,QAAM,cAAc;AAAA,IAChB,gBAAgB,iBAAiB;AAAA,EACzC;AACI,QAAM,eAAe;AAAA,IAAkC;AAAA,IAAiB;AAAA;AAAA,IAExE,mBAAmB,sBACf,CAAC,MAAM,QAAQ,eAAe,KAC9B,iBAAiB,gBAAgB,MAAM,KACvC,gBAAgB,OAAO,KAAK,SAAO,CAAC,IAAI,aAAa,eAAe,KAAK,eAAe,IAAI,WAAW,eAAe,CAAC,CAAC;AAAA,EAAC;AAC7H,QAAM,eAAe,oCAAoC,eAAe;AACxE,SAAO,IAAI,SAAS,SAAS,cAAc,YAAY;AAC3D;","x_google_ignoreList":[0]}