@slicemachine/manager 0.1.1-dev-plugins.3

package/dist/__node_modules/graphql/validation/rules/UniqueTypeNamesRule.js

@@ -0,0 +1,41 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueTypeNamesRule(context) {
+  const knownTypeNames = /* @__PURE__ */ Object.create(null);
+  const schema = context.getSchema();
+  return {
+    ScalarTypeDefinition: checkTypeName,
+    ObjectTypeDefinition: checkTypeName,
+    InterfaceTypeDefinition: checkTypeName,
+    UnionTypeDefinition: checkTypeName,
+    EnumTypeDefinition: checkTypeName,
+    InputObjectTypeDefinition: checkTypeName
+  };
+  function checkTypeName(node) {
+    const typeName = node.name.value;
+    if (schema !== null && schema !== void 0 && schema.getType(typeName)) {
+      context.reportError(
+        new GraphQLError(
+          `Type "${typeName}" already exists in the schema. It cannot also be defined in this type definition.`,
+          {
+            nodes: node.name
+          }
+        )
+      );
+      return;
+    }
+    if (knownTypeNames[typeName]) {
+      context.reportError(
+        new GraphQLError(`There can be only one type named "${typeName}".`, {
+          nodes: [knownTypeNames[typeName], node.name]
+        })
+      );
+    } else {
+      knownTypeNames[typeName] = node.name;
+    }
+    return false;
+  }
+}
+export {
+  UniqueTypeNamesRule
+};
+//# sourceMappingURL=UniqueTypeNamesRule.js.map

package/dist/__node_modules/graphql/validation/rules/UniqueTypeNamesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueTypeNamesRule.js","sources":["../../../../../../../node_modules/graphql/validation/rules/UniqueTypeNamesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique type names\n *\n * A GraphQL document is only valid if all defined types have unique names.\n */\nexport function UniqueTypeNamesRule(context) {\n  const knownTypeNames = Object.create(null);\n  const schema = context.getSchema();\n  return {\n    ScalarTypeDefinition: checkTypeName,\n    ObjectTypeDefinition: checkTypeName,\n    InterfaceTypeDefinition: checkTypeName,\n    UnionTypeDefinition: checkTypeName,\n    EnumTypeDefinition: checkTypeName,\n    InputObjectTypeDefinition: checkTypeName,\n  };\n\n  function checkTypeName(node) {\n    const typeName = node.name.value;\n\n    if (schema !== null && schema !== void 0 && schema.getType(typeName)) {\n      context.reportError(\n        new GraphQLError(\n          `Type \"${typeName}\" already exists in the schema. It cannot also be defined in this type definition.`,\n          {\n            nodes: node.name,\n          },\n        ),\n      );\n      return;\n    }\n\n    if (knownTypeNames[typeName]) {\n      context.reportError(\n        new GraphQLError(`There can be only one type named \"${typeName}\".`, {\n          nodes: [knownTypeNames[typeName], node.name],\n        }),\n      );\n    } else {\n      knownTypeNames[typeName] = node.name;\n    }\n\n    return false;\n  }\n}\n"],"names":[],"mappings":";AAOO,SAAS,oBAAoB,SAAS;AAC3C,QAAM,iBAAiB,uBAAO,OAAO,IAAI;AACzC,QAAM,SAAS,QAAQ;AACvB,SAAO;AAAA,IACL,sBAAsB;AAAA,IACtB,sBAAsB;AAAA,IACtB,yBAAyB;AAAA,IACzB,qBAAqB;AAAA,IACrB,oBAAoB;AAAA,IACpB,2BAA2B;AAAA,EAC/B;AAEE,WAAS,cAAc,MAAM;AAC3B,UAAM,WAAW,KAAK,KAAK;AAE3B,QAAI,WAAW,QAAQ,WAAW,UAAU,OAAO,QAAQ,QAAQ,GAAG;AACpE,cAAQ;AAAA,QACN,IAAI;AAAA,UACF,SAAS;AAAA,UACT;AAAA,YACE,OAAO,KAAK;AAAA,UACb;AAAA,QACF;AAAA,MACT;AACM;AAAA,IACD;AAED,QAAI,eAAe,QAAQ,GAAG;AAC5B,cAAQ;AAAA,QACN,IAAI,aAAa,qCAAqC,cAAc;AAAA,UAClE,OAAO,CAAC,eAAe,QAAQ,GAAG,KAAK,IAAI;AAAA,QACrD,CAAS;AAAA,MACT;AAAA,IACA,OAAW;AACL,qBAAe,QAAQ,IAAI,KAAK;AAAA,IACjC;AAED,WAAO;AAAA,EACR;AACH;"}

package/dist/__node_modules/graphql/validation/rules/UniqueVariableNamesRule.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const groupBy = require("../../jsutils/groupBy.cjs");
+const GraphQLError = require("../../error/GraphQLError.cjs");
+function UniqueVariableNamesRule(context) {
+  return {
+    OperationDefinition(operationNode) {
+      var _operationNode$variab;
+      const variableDefinitions = (_operationNode$variab = operationNode.variableDefinitions) !== null && _operationNode$variab !== void 0 ? _operationNode$variab : [];
+      const seenVariableDefinitions = groupBy.groupBy(
+        variableDefinitions,
+        (node) => node.variable.name.value
+      );
+      for (const [variableName, variableNodes] of seenVariableDefinitions) {
+        if (variableNodes.length > 1) {
+          context.reportError(
+            new GraphQLError.GraphQLError(
+              `There can be only one variable named "$${variableName}".`,
+              {
+                nodes: variableNodes.map((node) => node.variable.name)
+              }
+            )
+          );
+        }
+      }
+    }
+  };
+}
+exports.UniqueVariableNamesRule = UniqueVariableNamesRule;
+//# sourceMappingURL=UniqueVariableNamesRule.cjs.map

package/dist/__node_modules/graphql/validation/rules/UniqueVariableNamesRule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueVariableNamesRule.cjs","sources":["../../../../../../../node_modules/graphql/validation/rules/UniqueVariableNamesRule.mjs"],"sourcesContent":["import { groupBy } from '../../jsutils/groupBy.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique variable names\n *\n * A GraphQL operation is only valid if all its variables are uniquely named.\n */\nexport function UniqueVariableNamesRule(context) {\n  return {\n    OperationDefinition(operationNode) {\n      var _operationNode$variab;\n\n      // See: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const variableDefinitions =\n        (_operationNode$variab = operationNode.variableDefinitions) !== null &&\n        _operationNode$variab !== void 0\n          ? _operationNode$variab\n          : [];\n      const seenVariableDefinitions = groupBy(\n        variableDefinitions,\n        (node) => node.variable.name.value,\n      );\n\n      for (const [variableName, variableNodes] of seenVariableDefinitions) {\n        if (variableNodes.length > 1) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one variable named \"$${variableName}\".`,\n              {\n                nodes: variableNodes.map((node) => node.variable.name),\n              },\n            ),\n          );\n        }\n      }\n    },\n  };\n}\n"],"names":["groupBy","GraphQLError"],"mappings":";;;;AAQO,SAAS,wBAAwB,SAAS;AAC/C,SAAO;AAAA,IACL,oBAAoB,eAAe;AACjC,UAAI;AAKJ,YAAM,uBACH,wBAAwB,cAAc,yBAAyB,QAChE,0BAA0B,SACtB,wBACA;AACN,YAAM,0BAA0BA,QAAO;AAAA,QACrC;AAAA,QACA,CAAC,SAAS,KAAK,SAAS,KAAK;AAAA,MACrC;AAEM,iBAAW,CAAC,cAAc,aAAa,KAAK,yBAAyB;AACnE,YAAI,cAAc,SAAS,GAAG;AAC5B,kBAAQ;AAAA,YACN,IAAIC,aAAY;AAAA,cACd,0CAA0C;AAAA,cAC1C;AAAA,gBACE,OAAO,cAAc,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI;AAAA,cACtD;AAAA,YACF;AAAA,UACb;AAAA,QACS;AAAA,MACF;AAAA,IACF;AAAA,EACL;AACA;;"}

package/dist/__node_modules/graphql/validation/rules/UniqueVariableNamesRule.js

@@ -0,0 +1,30 @@
+import { groupBy } from "../../jsutils/groupBy.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueVariableNamesRule(context) {
+  return {
+    OperationDefinition(operationNode) {
+      var _operationNode$variab;
+      const variableDefinitions = (_operationNode$variab = operationNode.variableDefinitions) !== null && _operationNode$variab !== void 0 ? _operationNode$variab : [];
+      const seenVariableDefinitions = groupBy(
+        variableDefinitions,
+        (node) => node.variable.name.value
+      );
+      for (const [variableName, variableNodes] of seenVariableDefinitions) {
+        if (variableNodes.length > 1) {
+          context.reportError(
+            new GraphQLError(
+              `There can be only one variable named "$${variableName}".`,
+              {
+                nodes: variableNodes.map((node) => node.variable.name)
+              }
+            )
+          );
+        }
+      }
+    }
+  };
+}
+export {
+  UniqueVariableNamesRule
+};
+//# sourceMappingURL=UniqueVariableNamesRule.js.map

package/dist/__node_modules/graphql/validation/rules/UniqueVariableNamesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueVariableNamesRule.js","sources":["../../../../../../../node_modules/graphql/validation/rules/UniqueVariableNamesRule.mjs"],"sourcesContent":["import { groupBy } from '../../jsutils/groupBy.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique variable names\n *\n * A GraphQL operation is only valid if all its variables are uniquely named.\n */\nexport function UniqueVariableNamesRule(context) {\n  return {\n    OperationDefinition(operationNode) {\n      var _operationNode$variab;\n\n      // See: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const variableDefinitions =\n        (_operationNode$variab = operationNode.variableDefinitions) !== null &&\n        _operationNode$variab !== void 0\n          ? _operationNode$variab\n          : [];\n      const seenVariableDefinitions = groupBy(\n        variableDefinitions,\n        (node) => node.variable.name.value,\n      );\n\n      for (const [variableName, variableNodes] of seenVariableDefinitions) {\n        if (variableNodes.length > 1) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one variable named \"$${variableName}\".`,\n              {\n                nodes: variableNodes.map((node) => node.variable.name),\n              },\n            ),\n          );\n        }\n      }\n    },\n  };\n}\n"],"names":[],"mappings":";;AAQO,SAAS,wBAAwB,SAAS;AAC/C,SAAO;AAAA,IACL,oBAAoB,eAAe;AACjC,UAAI;AAKJ,YAAM,uBACH,wBAAwB,cAAc,yBAAyB,QAChE,0BAA0B,SACtB,wBACA;AACN,YAAM,0BAA0B;AAAA,QAC9B;AAAA,QACA,CAAC,SAAS,KAAK,SAAS,KAAK;AAAA,MACrC;AAEM,iBAAW,CAAC,cAAc,aAAa,KAAK,yBAAyB;AACnE,YAAI,cAAc,SAAS,GAAG;AAC5B,kBAAQ;AAAA,YACN,IAAI;AAAA,cACF,0CAA0C;AAAA,cAC1C;AAAA,gBACE,OAAO,cAAc,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI;AAAA,cACtD;AAAA,YACF;AAAA,UACb;AAAA,QACS;AAAA,MACF;AAAA,IACF;AAAA,EACL;AACA;"}

package/dist/__node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.cjs

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const didYouMean = require("../../jsutils/didYouMean.cjs");
+const inspect = require("../../jsutils/inspect.cjs");
+const keyMap = require("../../jsutils/keyMap.cjs");
+const suggestionList = require("../../jsutils/suggestionList.cjs");
+const GraphQLError = require("../../error/GraphQLError.cjs");
+const printer = require("../../language/printer.cjs");
+const definition = require("../../type/definition.cjs");
+function ValuesOfCorrectTypeRule(context) {
+  return {
+    ListValue(node) {
+      const type = definition.getNullableType(context.getParentInputType());
+      if (!definition.isListType(type)) {
+        isValidValueNode(context, node);
+        return false;
+      }
+    },
+    ObjectValue(node) {
+      const type = definition.getNamedType(context.getInputType());
+      if (!definition.isInputObjectType(type)) {
+        isValidValueNode(context, node);
+        return false;
+      }
+      const fieldNodeMap = keyMap.keyMap(node.fields, (field) => field.name.value);
+      for (const fieldDef of Object.values(type.getFields())) {
+        const fieldNode = fieldNodeMap[fieldDef.name];
+        if (!fieldNode && definition.isRequiredInputField(fieldDef)) {
+          const typeStr = inspect.inspect(fieldDef.type);
+          context.reportError(
+            new GraphQLError.GraphQLError(
+              `Field "${type.name}.${fieldDef.name}" of required type "${typeStr}" was not provided.`,
+              {
+                nodes: node
+              }
+            )
+          );
+        }
+      }
+    },
+    ObjectField(node) {
+      const parentType = definition.getNamedType(context.getParentInputType());
+      const fieldType = context.getInputType();
+      if (!fieldType && definition.isInputObjectType(parentType)) {
+        const suggestions = suggestionList.suggestionList(
+          node.name.value,
+          Object.keys(parentType.getFields())
+        );
+        context.reportError(
+          new GraphQLError.GraphQLError(
+            `Field "${node.name.value}" is not defined by type "${parentType.name}".` + didYouMean.didYouMean(suggestions),
+            {
+              nodes: node
+            }
+          )
+        );
+      }
+    },
+    NullValue(node) {
+      const type = context.getInputType();
+      if (definition.isNonNullType(type)) {
+        context.reportError(
+          new GraphQLError.GraphQLError(
+            `Expected value of type "${inspect.inspect(type)}", found ${printer.print(node)}.`,
+            {
+              nodes: node
+            }
+          )
+        );
+      }
+    },
+    EnumValue: (node) => isValidValueNode(context, node),
+    IntValue: (node) => isValidValueNode(context, node),
+    FloatValue: (node) => isValidValueNode(context, node),
+    StringValue: (node) => isValidValueNode(context, node),
+    BooleanValue: (node) => isValidValueNode(context, node)
+  };
+}
+function isValidValueNode(context, node) {
+  const locationType = context.getInputType();
+  if (!locationType) {
+    return;
+  }
+  const type = definition.getNamedType(locationType);
+  if (!definition.isLeafType(type)) {
+    const typeStr = inspect.inspect(locationType);
+    context.reportError(
+      new GraphQLError.GraphQLError(
+        `Expected value of type "${typeStr}", found ${printer.print(node)}.`,
+        {
+          nodes: node
+        }
+      )
+    );
+    return;
+  }
+  try {
+    const parseResult = type.parseLiteral(
+      node,
+      void 0
+      /* variables */
+    );
+    if (parseResult === void 0) {
+      const typeStr = inspect.inspect(locationType);
+      context.reportError(
+        new GraphQLError.GraphQLError(
+          `Expected value of type "${typeStr}", found ${printer.print(node)}.`,
+          {
+            nodes: node
+          }
+        )
+      );
+    }
+  } catch (error) {
+    const typeStr = inspect.inspect(locationType);
+    if (error instanceof GraphQLError.GraphQLError) {
+      context.reportError(error);
+    } else {
+      context.reportError(
+        new GraphQLError.GraphQLError(
+          `Expected value of type "${typeStr}", found ${printer.print(node)}; ` + error.message,
+          {
+            nodes: node,
+            originalError: error
+          }
+        )
+      );
+    }
+  }
+}
+exports.ValuesOfCorrectTypeRule = ValuesOfCorrectTypeRule;
+//# sourceMappingURL=ValuesOfCorrectTypeRule.cjs.map

package/dist/__node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValuesOfCorrectTypeRule.cjs","sources":["../../../../../../../node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.mjs"],"sourcesContent":["import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { inspect } from '../../jsutils/inspect.mjs';\nimport { keyMap } from '../../jsutils/keyMap.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport {\n  getNamedType,\n  getNullableType,\n  isInputObjectType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n  isRequiredInputField,\n} from '../../type/definition.mjs';\n\n/**\n * Value literals of correct type\n *\n * A GraphQL document is only valid if all value literals are of the type\n * expected at their position.\n *\n * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type\n */\nexport function ValuesOfCorrectTypeRule(context) {\n  return {\n    ListValue(node) {\n      // Note: TypeInfo will traverse into a list's item type, so look to the\n      // parent input type to check if it is a list.\n      const type = getNullableType(context.getParentInputType());\n\n      if (!isListType(type)) {\n        isValidValueNode(context, node);\n        return false; // Don't traverse further.\n      }\n    },\n\n    ObjectValue(node) {\n      const type = getNamedType(context.getInputType());\n\n      if (!isInputObjectType(type)) {\n        isValidValueNode(context, node);\n        return false; // Don't traverse further.\n      } // Ensure every required field exists.\n\n      const fieldNodeMap = keyMap(node.fields, (field) => field.name.value);\n\n      for (const fieldDef of Object.values(type.getFields())) {\n        const fieldNode = fieldNodeMap[fieldDef.name];\n\n        if (!fieldNode && isRequiredInputField(fieldDef)) {\n          const typeStr = inspect(fieldDef.type);\n          context.reportError(\n            new GraphQLError(\n              `Field \"${type.name}.${fieldDef.name}\" of required type \"${typeStr}\" was not provided.`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n\n    ObjectField(node) {\n      const parentType = getNamedType(context.getParentInputType());\n      const fieldType = context.getInputType();\n\n      if (!fieldType && isInputObjectType(parentType)) {\n        const suggestions = suggestionList(\n          node.name.value,\n          Object.keys(parentType.getFields()),\n        );\n        context.reportError(\n          new GraphQLError(\n            `Field \"${node.name.value}\" is not defined by type \"${parentType.name}\".` +\n              didYouMean(suggestions),\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    NullValue(node) {\n      const type = context.getInputType();\n\n      if (isNonNullType(type)) {\n        context.reportError(\n          new GraphQLError(\n            `Expected value of type \"${inspect(type)}\", found ${print(node)}.`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    EnumValue: (node) => isValidValueNode(context, node),\n    IntValue: (node) => isValidValueNode(context, node),\n    FloatValue: (node) => isValidValueNode(context, node),\n    StringValue: (node) => isValidValueNode(context, node),\n    BooleanValue: (node) => isValidValueNode(context, node),\n  };\n}\n/**\n * Any value literal may be a valid representation of a Scalar, depending on\n * that scalar type.\n */\n\nfunction isValidValueNode(context, node) {\n  // Report any error at the full type expected by the location.\n  const locationType = context.getInputType();\n\n  if (!locationType) {\n    return;\n  }\n\n  const type = getNamedType(locationType);\n\n  if (!isLeafType(type)) {\n    const typeStr = inspect(locationType);\n    context.reportError(\n      new GraphQLError(\n        `Expected value of type \"${typeStr}\", found ${print(node)}.`,\n        {\n          nodes: node,\n        },\n      ),\n    );\n    return;\n  } // Scalars and Enums determine if a literal value is valid via parseLiteral(),\n  // which may throw or return an invalid value to indicate failure.\n\n  try {\n    const parseResult = type.parseLiteral(\n      node,\n      undefined,\n      /* variables */\n    );\n\n    if (parseResult === undefined) {\n      const typeStr = inspect(locationType);\n      context.reportError(\n        new GraphQLError(\n          `Expected value of type \"${typeStr}\", found ${print(node)}.`,\n          {\n            nodes: node,\n          },\n        ),\n      );\n    }\n  } catch (error) {\n    const typeStr = inspect(locationType);\n\n    if (error instanceof GraphQLError) {\n      context.reportError(error);\n    } else {\n      context.reportError(\n        new GraphQLError(\n          `Expected value of type \"${typeStr}\", found ${print(node)}; ` +\n            error.message,\n          {\n            nodes: node,\n            originalError: error,\n          },\n        ),\n      );\n    }\n  }\n}\n"],"names":["getNullableType","isListType","getNamedType","isInputObjectType","keyMap","isRequiredInputField","inspect","GraphQLError","suggestionList","didYouMean","isNonNullType","print","isLeafType"],"mappings":"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"}

package/dist/__node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.js

@@ -0,0 +1,132 @@
+import { didYouMean } from "../../jsutils/didYouMean.js";
+import { inspect } from "../../jsutils/inspect.js";
+import { keyMap } from "../../jsutils/keyMap.js";
+import { suggestionList } from "../../jsutils/suggestionList.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { print } from "../../language/printer.js";
+import { getNullableType, isListType, getNamedType, isInputObjectType, isRequiredInputField, isNonNullType, isLeafType } from "../../type/definition.js";
+function ValuesOfCorrectTypeRule(context) {
+  return {
+    ListValue(node) {
+      const type = getNullableType(context.getParentInputType());
+      if (!isListType(type)) {
+        isValidValueNode(context, node);
+        return false;
+      }
+    },
+    ObjectValue(node) {
+      const type = getNamedType(context.getInputType());
+      if (!isInputObjectType(type)) {
+        isValidValueNode(context, node);
+        return false;
+      }
+      const fieldNodeMap = keyMap(node.fields, (field) => field.name.value);
+      for (const fieldDef of Object.values(type.getFields())) {
+        const fieldNode = fieldNodeMap[fieldDef.name];
+        if (!fieldNode && isRequiredInputField(fieldDef)) {
+          const typeStr = inspect(fieldDef.type);
+          context.reportError(
+            new GraphQLError(
+              `Field "${type.name}.${fieldDef.name}" of required type "${typeStr}" was not provided.`,
+              {
+                nodes: node
+              }
+            )
+          );
+        }
+      }
+    },
+    ObjectField(node) {
+      const parentType = getNamedType(context.getParentInputType());
+      const fieldType = context.getInputType();
+      if (!fieldType && isInputObjectType(parentType)) {
+        const suggestions = suggestionList(
+          node.name.value,
+          Object.keys(parentType.getFields())
+        );
+        context.reportError(
+          new GraphQLError(
+            `Field "${node.name.value}" is not defined by type "${parentType.name}".` + didYouMean(suggestions),
+            {
+              nodes: node
+            }
+          )
+        );
+      }
+    },
+    NullValue(node) {
+      const type = context.getInputType();
+      if (isNonNullType(type)) {
+        context.reportError(
+          new GraphQLError(
+            `Expected value of type "${inspect(type)}", found ${print(node)}.`,
+            {
+              nodes: node
+            }
+          )
+        );
+      }
+    },
+    EnumValue: (node) => isValidValueNode(context, node),
+    IntValue: (node) => isValidValueNode(context, node),
+    FloatValue: (node) => isValidValueNode(context, node),
+    StringValue: (node) => isValidValueNode(context, node),
+    BooleanValue: (node) => isValidValueNode(context, node)
+  };
+}
+function isValidValueNode(context, node) {
+  const locationType = context.getInputType();
+  if (!locationType) {
+    return;
+  }
+  const type = getNamedType(locationType);
+  if (!isLeafType(type)) {
+    const typeStr = inspect(locationType);
+    context.reportError(
+      new GraphQLError(
+        `Expected value of type "${typeStr}", found ${print(node)}.`,
+        {
+          nodes: node
+        }
+      )
+    );
+    return;
+  }
+  try {
+    const parseResult = type.parseLiteral(
+      node,
+      void 0
+      /* variables */
+    );
+    if (parseResult === void 0) {
+      const typeStr = inspect(locationType);
+      context.reportError(
+        new GraphQLError(
+          `Expected value of type "${typeStr}", found ${print(node)}.`,
+          {
+            nodes: node
+          }
+        )
+      );
+    }
+  } catch (error) {
+    const typeStr = inspect(locationType);
+    if (error instanceof GraphQLError) {
+      context.reportError(error);
+    } else {
+      context.reportError(
+        new GraphQLError(
+          `Expected value of type "${typeStr}", found ${print(node)}; ` + error.message,
+          {
+            nodes: node,
+            originalError: error
+          }
+        )
+      );
+    }
+  }
+}
+export {
+  ValuesOfCorrectTypeRule
+};
+//# sourceMappingURL=ValuesOfCorrectTypeRule.js.map

package/dist/__node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValuesOfCorrectTypeRule.js","sources":["../../../../../../../node_modules/graphql/validation/rules/ValuesOfCorrectTypeRule.mjs"],"sourcesContent":["import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { inspect } from '../../jsutils/inspect.mjs';\nimport { keyMap } from '../../jsutils/keyMap.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport {\n  getNamedType,\n  getNullableType,\n  isInputObjectType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n  isRequiredInputField,\n} from '../../type/definition.mjs';\n\n/**\n * Value literals of correct type\n *\n * A GraphQL document is only valid if all value literals are of the type\n * expected at their position.\n *\n * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type\n */\nexport function ValuesOfCorrectTypeRule(context) {\n  return {\n    ListValue(node) {\n      // Note: TypeInfo will traverse into a list's item type, so look to the\n      // parent input type to check if it is a list.\n      const type = getNullableType(context.getParentInputType());\n\n      if (!isListType(type)) {\n        isValidValueNode(context, node);\n        return false; // Don't traverse further.\n      }\n    },\n\n    ObjectValue(node) {\n      const type = getNamedType(context.getInputType());\n\n      if (!isInputObjectType(type)) {\n        isValidValueNode(context, node);\n        return false; // Don't traverse further.\n      } // Ensure every required field exists.\n\n      const fieldNodeMap = keyMap(node.fields, (field) => field.name.value);\n\n      for (const fieldDef of Object.values(type.getFields())) {\n        const fieldNode = fieldNodeMap[fieldDef.name];\n\n        if (!fieldNode && isRequiredInputField(fieldDef)) {\n          const typeStr = inspect(fieldDef.type);\n          context.reportError(\n            new GraphQLError(\n              `Field \"${type.name}.${fieldDef.name}\" of required type \"${typeStr}\" was not provided.`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n\n    ObjectField(node) {\n      const parentType = getNamedType(context.getParentInputType());\n      const fieldType = context.getInputType();\n\n      if (!fieldType && isInputObjectType(parentType)) {\n        const suggestions = suggestionList(\n          node.name.value,\n          Object.keys(parentType.getFields()),\n        );\n        context.reportError(\n          new GraphQLError(\n            `Field \"${node.name.value}\" is not defined by type \"${parentType.name}\".` +\n              didYouMean(suggestions),\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    NullValue(node) {\n      const type = context.getInputType();\n\n      if (isNonNullType(type)) {\n        context.reportError(\n          new GraphQLError(\n            `Expected value of type \"${inspect(type)}\", found ${print(node)}.`,\n            {\n              nodes: node,\n            },\n          ),\n        );\n      }\n    },\n\n    EnumValue: (node) => isValidValueNode(context, node),\n    IntValue: (node) => isValidValueNode(context, node),\n    FloatValue: (node) => isValidValueNode(context, node),\n    StringValue: (node) => isValidValueNode(context, node),\n    BooleanValue: (node) => isValidValueNode(context, node),\n  };\n}\n/**\n * Any value literal may be a valid representation of a Scalar, depending on\n * that scalar type.\n */\n\nfunction isValidValueNode(context, node) {\n  // Report any error at the full type expected by the location.\n  const locationType = context.getInputType();\n\n  if (!locationType) {\n    return;\n  }\n\n  const type = getNamedType(locationType);\n\n  if (!isLeafType(type)) {\n    const typeStr = inspect(locationType);\n    context.reportError(\n      new GraphQLError(\n        `Expected value of type \"${typeStr}\", found ${print(node)}.`,\n        {\n          nodes: node,\n        },\n      ),\n    );\n    return;\n  } // Scalars and Enums determine if a literal value is valid via parseLiteral(),\n  // which may throw or return an invalid value to indicate failure.\n\n  try {\n    const parseResult = type.parseLiteral(\n      node,\n      undefined,\n      /* variables */\n    );\n\n    if (parseResult === undefined) {\n      const typeStr = inspect(locationType);\n      context.reportError(\n        new GraphQLError(\n          `Expected value of type \"${typeStr}\", found ${print(node)}.`,\n          {\n            nodes: node,\n          },\n        ),\n      );\n    }\n  } catch (error) {\n    const typeStr = inspect(locationType);\n\n    if (error instanceof GraphQLError) {\n      context.reportError(error);\n    } else {\n      context.reportError(\n        new GraphQLError(\n          `Expected value of type \"${typeStr}\", found ${print(node)}; ` +\n            error.message,\n          {\n            nodes: node,\n            originalError: error,\n          },\n        ),\n      );\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/__node_modules/graphql/validation/rules/VariablesAreInputTypesRule.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const GraphQLError = require("../../error/GraphQLError.cjs");
+const printer = require("../../language/printer.cjs");
+const definition = require("../../type/definition.cjs");
+const typeFromAST = require("../../utilities/typeFromAST.cjs");
+function VariablesAreInputTypesRule(context) {
+  return {
+    VariableDefinition(node) {
+      const type = typeFromAST.typeFromAST(context.getSchema(), node.type);
+      if (type !== void 0 && !definition.isInputType(type)) {
+        const variableName = node.variable.name.value;
+        const typeName = printer.print(node.type);
+        context.reportError(
+          new GraphQLError.GraphQLError(
+            `Variable "$${variableName}" cannot be non-input type "${typeName}".`,
+            {
+              nodes: node.type
+            }
+          )
+        );
+      }
+    }
+  };
+}
+exports.VariablesAreInputTypesRule = VariablesAreInputTypesRule;
+//# sourceMappingURL=VariablesAreInputTypesRule.cjs.map

package/dist/__node_modules/graphql/validation/rules/VariablesAreInputTypesRule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariablesAreInputTypesRule.cjs","sources":["../../../../../../../node_modules/graphql/validation/rules/VariablesAreInputTypesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport { isInputType } from '../../type/definition.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Variables are input types\n *\n * A GraphQL operation is only valid if all the variables it defines are of\n * input types (scalar, enum, or input object).\n *\n * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types\n */\nexport function VariablesAreInputTypesRule(context) {\n  return {\n    VariableDefinition(node) {\n      const type = typeFromAST(context.getSchema(), node.type);\n\n      if (type !== undefined && !isInputType(type)) {\n        const variableName = node.variable.name.value;\n        const typeName = print(node.type);\n        context.reportError(\n          new GraphQLError(\n            `Variable \"$${variableName}\" cannot be non-input type \"${typeName}\".`,\n            {\n              nodes: node.type,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n"],"names":["typeFromAST","isInputType","print","GraphQLError"],"mappings":";;;;;;AAaO,SAAS,2BAA2B,SAAS;AAClD,SAAO;AAAA,IACL,mBAAmB,MAAM;AACvB,YAAM,OAAOA,YAAAA,YAAY,QAAQ,UAAS,GAAI,KAAK,IAAI;AAEvD,UAAI,SAAS,UAAa,CAACC,WAAW,YAAC,IAAI,GAAG;AAC5C,cAAM,eAAe,KAAK,SAAS,KAAK;AACxC,cAAM,WAAWC,QAAAA,MAAM,KAAK,IAAI;AAChC,gBAAQ;AAAA,UACN,IAAIC,aAAY;AAAA,YACd,cAAc,2CAA2C;AAAA,YACzD;AAAA,cACE,OAAO,KAAK;AAAA,YACb;AAAA,UACF;AAAA,QACX;AAAA,MACO;AAAA,IACF;AAAA,EACL;AACA;;"}

package/dist/__node_modules/graphql/validation/rules/VariablesAreInputTypesRule.js

@@ -0,0 +1,27 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { print } from "../../language/printer.js";
+import { isInputType } from "../../type/definition.js";
+import { typeFromAST } from "../../utilities/typeFromAST.js";
+function VariablesAreInputTypesRule(context) {
+  return {
+    VariableDefinition(node) {
+      const type = typeFromAST(context.getSchema(), node.type);
+      if (type !== void 0 && !isInputType(type)) {
+        const variableName = node.variable.name.value;
+        const typeName = print(node.type);
+        context.reportError(
+          new GraphQLError(
+            `Variable "$${variableName}" cannot be non-input type "${typeName}".`,
+            {
+              nodes: node.type
+            }
+          )
+        );
+      }
+    }
+  };
+}
+export {
+  VariablesAreInputTypesRule
+};
+//# sourceMappingURL=VariablesAreInputTypesRule.js.map

package/dist/__node_modules/graphql/validation/rules/VariablesAreInputTypesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariablesAreInputTypesRule.js","sources":["../../../../../../../node_modules/graphql/validation/rules/VariablesAreInputTypesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport { isInputType } from '../../type/definition.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Variables are input types\n *\n * A GraphQL operation is only valid if all the variables it defines are of\n * input types (scalar, enum, or input object).\n *\n * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types\n */\nexport function VariablesAreInputTypesRule(context) {\n  return {\n    VariableDefinition(node) {\n      const type = typeFromAST(context.getSchema(), node.type);\n\n      if (type !== undefined && !isInputType(type)) {\n        const variableName = node.variable.name.value;\n        const typeName = print(node.type);\n        context.reportError(\n          new GraphQLError(\n            `Variable \"$${variableName}\" cannot be non-input type \"${typeName}\".`,\n            {\n              nodes: node.type,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n"],"names":[],"mappings":";;;;AAaO,SAAS,2BAA2B,SAAS;AAClD,SAAO;AAAA,IACL,mBAAmB,MAAM;AACvB,YAAM,OAAO,YAAY,QAAQ,UAAS,GAAI,KAAK,IAAI;AAEvD,UAAI,SAAS,UAAa,CAAC,YAAY,IAAI,GAAG;AAC5C,cAAM,eAAe,KAAK,SAAS,KAAK;AACxC,cAAM,WAAW,MAAM,KAAK,IAAI;AAChC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,cAAc,2CAA2C;AAAA,YACzD;AAAA,cACE,OAAO,KAAK;AAAA,YACb;AAAA,UACF;AAAA,QACX;AAAA,MACO;AAAA,IACF;AAAA,EACL;AACA;"}

package/dist/__node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const inspect = require("../../jsutils/inspect.cjs");
+const GraphQLError = require("../../error/GraphQLError.cjs");
+const kinds = require("../../language/kinds.cjs");
+const definition = require("../../type/definition.cjs");
+const typeComparators = require("../../utilities/typeComparators.cjs");
+const typeFromAST = require("../../utilities/typeFromAST.cjs");
+function VariablesInAllowedPositionRule(context) {
+  let varDefMap = /* @__PURE__ */ Object.create(null);
+  return {
+    OperationDefinition: {
+      enter() {
+        varDefMap = /* @__PURE__ */ Object.create(null);
+      },
+      leave(operation) {
+        const usages = context.getRecursiveVariableUsages(operation);
+        for (const { node, type, defaultValue } of usages) {
+          const varName = node.name.value;
+          const varDef = varDefMap[varName];
+          if (varDef && type) {
+            const schema = context.getSchema();
+            const varType = typeFromAST.typeFromAST(schema, varDef.type);
+            if (varType && !allowedVariableUsage(
+              schema,
+              varType,
+              varDef.defaultValue,
+              type,
+              defaultValue
+            )) {
+              const varTypeStr = inspect.inspect(varType);
+              const typeStr = inspect.inspect(type);
+              context.reportError(
+                new GraphQLError.GraphQLError(
+                  `Variable "$${varName}" of type "${varTypeStr}" used in position expecting type "${typeStr}".`,
+                  {
+                    nodes: [varDef, node]
+                  }
+                )
+              );
+            }
+          }
+        }
+      }
+    },
+    VariableDefinition(node) {
+      varDefMap[node.variable.name.value] = node;
+    }
+  };
+}
+function allowedVariableUsage(schema, varType, varDefaultValue, locationType, locationDefaultValue) {
+  if (definition.isNonNullType(locationType) && !definition.isNonNullType(varType)) {
+    const hasNonNullVariableDefaultValue = varDefaultValue != null && varDefaultValue.kind !== kinds.Kind.NULL;
+    const hasLocationDefaultValue = locationDefaultValue !== void 0;
+    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
+      return false;
+    }
+    const nullableLocationType = locationType.ofType;
+    return typeComparators.isTypeSubTypeOf(schema, varType, nullableLocationType);
+  }
+  return typeComparators.isTypeSubTypeOf(schema, varType, locationType);
+}
+exports.VariablesInAllowedPositionRule = VariablesInAllowedPositionRule;
+//# sourceMappingURL=VariablesInAllowedPositionRule.cjs.map

package/dist/__node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariablesInAllowedPositionRule.cjs","sources":["../../../../../../../node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.mjs"],"sourcesContent":["import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { isNonNullType } from '../../type/definition.mjs';\nimport { isTypeSubTypeOf } from '../../utilities/typeComparators.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Variables in allowed position\n *\n * Variable usages must be compatible with the arguments they are passed to.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed\n */\nexport function VariablesInAllowedPositionRule(context) {\n  let varDefMap = Object.create(null);\n  return {\n    OperationDefinition: {\n      enter() {\n        varDefMap = Object.create(null);\n      },\n\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const { node, type, defaultValue } of usages) {\n          const varName = node.name.value;\n          const varDef = varDefMap[varName];\n\n          if (varDef && type) {\n            // A var type is allowed if it is the same or more strict (e.g. is\n            // a subtype of) than the expected type. It can be more strict if\n            // the variable type is non-null when the expected type is nullable.\n            // If both are list types, the variable item type can be more strict\n            // than the expected item type (contravariant).\n            const schema = context.getSchema();\n            const varType = typeFromAST(schema, varDef.type);\n\n            if (\n              varType &&\n              !allowedVariableUsage(\n                schema,\n                varType,\n                varDef.defaultValue,\n                type,\n                defaultValue,\n              )\n            ) {\n              const varTypeStr = inspect(varType);\n              const typeStr = inspect(type);\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" of type \"${varTypeStr}\" used in position expecting type \"${typeStr}\".`,\n                  {\n                    nodes: [varDef, node],\n                  },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n\n    VariableDefinition(node) {\n      varDefMap[node.variable.name.value] = node;\n    },\n  };\n}\n/**\n * Returns true if the variable is allowed in the location it was found,\n * which includes considering if default values exist for either the variable\n * or the location at which it is located.\n */\n\nfunction allowedVariableUsage(\n  schema,\n  varType,\n  varDefaultValue,\n  locationType,\n  locationDefaultValue,\n) {\n  if (isNonNullType(locationType) && !isNonNullType(varType)) {\n    const hasNonNullVariableDefaultValue =\n      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;\n    const hasLocationDefaultValue = locationDefaultValue !== undefined;\n\n    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {\n      return false;\n    }\n\n    const nullableLocationType = locationType.ofType;\n    return isTypeSubTypeOf(schema, varType, nullableLocationType);\n  }\n\n  return isTypeSubTypeOf(schema, varType, locationType);\n}\n"],"names":["typeFromAST","inspect","GraphQLError","isNonNullType","Kind","isTypeSubTypeOf"],"mappings":";;;;;;;;AAcO,SAAS,+BAA+B,SAAS;AACtD,MAAI,YAAY,uBAAO,OAAO,IAAI;AAClC,SAAO;AAAA,IACL,qBAAqB;AAAA,MACnB,QAAQ;AACN,oBAAY,uBAAO,OAAO,IAAI;AAAA,MAC/B;AAAA,MAED,MAAM,WAAW;AACf,cAAM,SAAS,QAAQ,2BAA2B,SAAS;AAE3D,mBAAW,EAAE,MAAM,MAAM,aAAY,KAAM,QAAQ;AACjD,gBAAM,UAAU,KAAK,KAAK;AAC1B,gBAAM,SAAS,UAAU,OAAO;AAEhC,cAAI,UAAU,MAAM;AAMlB,kBAAM,SAAS,QAAQ;AACvB,kBAAM,UAAUA,YAAW,YAAC,QAAQ,OAAO,IAAI;AAE/C,gBACE,WACA,CAAC;AAAA,cACC;AAAA,cACA;AAAA,cACA,OAAO;AAAA,cACP;AAAA,cACA;AAAA,YACD,GACD;AACA,oBAAM,aAAaC,gBAAQ,OAAO;AAClC,oBAAM,UAAUA,gBAAQ,IAAI;AAC5B,sBAAQ;AAAA,gBACN,IAAIC,aAAY;AAAA,kBACd,cAAc,qBAAqB,gDAAgD;AAAA,kBACnF;AAAA,oBACE,OAAO,CAAC,QAAQ,IAAI;AAAA,kBACrB;AAAA,gBACF;AAAA,cACjB;AAAA,YACa;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IAED,mBAAmB,MAAM;AACvB,gBAAU,KAAK,SAAS,KAAK,KAAK,IAAI;AAAA,IACvC;AAAA,EACL;AACA;AAOA,SAAS,qBACP,QACA,SACA,iBACA,cACA,sBACA;AACA,MAAIC,WAAa,cAAC,YAAY,KAAK,CAACA,WAAa,cAAC,OAAO,GAAG;AAC1D,UAAM,iCACJ,mBAAmB,QAAQ,gBAAgB,SAASC,MAAAA,KAAK;AAC3D,UAAM,0BAA0B,yBAAyB;AAEzD,QAAI,CAAC,kCAAkC,CAAC,yBAAyB;AAC/D,aAAO;AAAA,IACR;AAED,UAAM,uBAAuB,aAAa;AAC1C,WAAOC,gCAAgB,QAAQ,SAAS,oBAAoB;AAAA,EAC7D;AAED,SAAOA,gCAAgB,QAAQ,SAAS,YAAY;AACtD;;"}

package/dist/__node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.js

@@ -0,0 +1,64 @@
+import { inspect } from "../../jsutils/inspect.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { isNonNullType } from "../../type/definition.js";
+import { isTypeSubTypeOf } from "../../utilities/typeComparators.js";
+import { typeFromAST } from "../../utilities/typeFromAST.js";
+function VariablesInAllowedPositionRule(context) {
+  let varDefMap = /* @__PURE__ */ Object.create(null);
+  return {
+    OperationDefinition: {
+      enter() {
+        varDefMap = /* @__PURE__ */ Object.create(null);
+      },
+      leave(operation) {
+        const usages = context.getRecursiveVariableUsages(operation);
+        for (const { node, type, defaultValue } of usages) {
+          const varName = node.name.value;
+          const varDef = varDefMap[varName];
+          if (varDef && type) {
+            const schema = context.getSchema();
+            const varType = typeFromAST(schema, varDef.type);
+            if (varType && !allowedVariableUsage(
+              schema,
+              varType,
+              varDef.defaultValue,
+              type,
+              defaultValue
+            )) {
+              const varTypeStr = inspect(varType);
+              const typeStr = inspect(type);
+              context.reportError(
+                new GraphQLError(
+                  `Variable "$${varName}" of type "${varTypeStr}" used in position expecting type "${typeStr}".`,
+                  {
+                    nodes: [varDef, node]
+                  }
+                )
+              );
+            }
+          }
+        }
+      }
+    },
+    VariableDefinition(node) {
+      varDefMap[node.variable.name.value] = node;
+    }
+  };
+}
+function allowedVariableUsage(schema, varType, varDefaultValue, locationType, locationDefaultValue) {
+  if (isNonNullType(locationType) && !isNonNullType(varType)) {
+    const hasNonNullVariableDefaultValue = varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;
+    const hasLocationDefaultValue = locationDefaultValue !== void 0;
+    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
+      return false;
+    }
+    const nullableLocationType = locationType.ofType;
+    return isTypeSubTypeOf(schema, varType, nullableLocationType);
+  }
+  return isTypeSubTypeOf(schema, varType, locationType);
+}
+export {
+  VariablesInAllowedPositionRule
+};
+//# sourceMappingURL=VariablesInAllowedPositionRule.js.map

package/dist/__node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariablesInAllowedPositionRule.js","sources":["../../../../../../../node_modules/graphql/validation/rules/VariablesInAllowedPositionRule.mjs"],"sourcesContent":["import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { isNonNullType } from '../../type/definition.mjs';\nimport { isTypeSubTypeOf } from '../../utilities/typeComparators.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Variables in allowed position\n *\n * Variable usages must be compatible with the arguments they are passed to.\n *\n * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed\n */\nexport function VariablesInAllowedPositionRule(context) {\n  let varDefMap = Object.create(null);\n  return {\n    OperationDefinition: {\n      enter() {\n        varDefMap = Object.create(null);\n      },\n\n      leave(operation) {\n        const usages = context.getRecursiveVariableUsages(operation);\n\n        for (const { node, type, defaultValue } of usages) {\n          const varName = node.name.value;\n          const varDef = varDefMap[varName];\n\n          if (varDef && type) {\n            // A var type is allowed if it is the same or more strict (e.g. is\n            // a subtype of) than the expected type. It can be more strict if\n            // the variable type is non-null when the expected type is nullable.\n            // If both are list types, the variable item type can be more strict\n            // than the expected item type (contravariant).\n            const schema = context.getSchema();\n            const varType = typeFromAST(schema, varDef.type);\n\n            if (\n              varType &&\n              !allowedVariableUsage(\n                schema,\n                varType,\n                varDef.defaultValue,\n                type,\n                defaultValue,\n              )\n            ) {\n              const varTypeStr = inspect(varType);\n              const typeStr = inspect(type);\n              context.reportError(\n                new GraphQLError(\n                  `Variable \"$${varName}\" of type \"${varTypeStr}\" used in position expecting type \"${typeStr}\".`,\n                  {\n                    nodes: [varDef, node],\n                  },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n\n    VariableDefinition(node) {\n      varDefMap[node.variable.name.value] = node;\n    },\n  };\n}\n/**\n * Returns true if the variable is allowed in the location it was found,\n * which includes considering if default values exist for either the variable\n * or the location at which it is located.\n */\n\nfunction allowedVariableUsage(\n  schema,\n  varType,\n  varDefaultValue,\n  locationType,\n  locationDefaultValue,\n) {\n  if (isNonNullType(locationType) && !isNonNullType(varType)) {\n    const hasNonNullVariableDefaultValue =\n      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;\n    const hasLocationDefaultValue = locationDefaultValue !== undefined;\n\n    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {\n      return false;\n    }\n\n    const nullableLocationType = locationType.ofType;\n    return isTypeSubTypeOf(schema, varType, nullableLocationType);\n  }\n\n  return isTypeSubTypeOf(schema, varType, locationType);\n}\n"],"names":[],"mappings":";;;;;;AAcO,SAAS,+BAA+B,SAAS;AACtD,MAAI,YAAY,uBAAO,OAAO,IAAI;AAClC,SAAO;AAAA,IACL,qBAAqB;AAAA,MACnB,QAAQ;AACN,oBAAY,uBAAO,OAAO,IAAI;AAAA,MAC/B;AAAA,MAED,MAAM,WAAW;AACf,cAAM,SAAS,QAAQ,2BAA2B,SAAS;AAE3D,mBAAW,EAAE,MAAM,MAAM,aAAY,KAAM,QAAQ;AACjD,gBAAM,UAAU,KAAK,KAAK;AAC1B,gBAAM,SAAS,UAAU,OAAO;AAEhC,cAAI,UAAU,MAAM;AAMlB,kBAAM,SAAS,QAAQ;AACvB,kBAAM,UAAU,YAAY,QAAQ,OAAO,IAAI;AAE/C,gBACE,WACA,CAAC;AAAA,cACC;AAAA,cACA;AAAA,cACA,OAAO;AAAA,cACP;AAAA,cACA;AAAA,YACD,GACD;AACA,oBAAM,aAAa,QAAQ,OAAO;AAClC,oBAAM,UAAU,QAAQ,IAAI;AAC5B,sBAAQ;AAAA,gBACN,IAAI;AAAA,kBACF,cAAc,qBAAqB,gDAAgD;AAAA,kBACnF;AAAA,oBACE,OAAO,CAAC,QAAQ,IAAI;AAAA,kBACrB;AAAA,gBACF;AAAA,cACjB;AAAA,YACa;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IAED,mBAAmB,MAAM;AACvB,gBAAU,KAAK,SAAS,KAAK,KAAK,IAAI;AAAA,IACvC;AAAA,EACL;AACA;AAOA,SAAS,qBACP,QACA,SACA,iBACA,cACA,sBACA;AACA,MAAI,cAAc,YAAY,KAAK,CAAC,cAAc,OAAO,GAAG;AAC1D,UAAM,iCACJ,mBAAmB,QAAQ,gBAAgB,SAAS,KAAK;AAC3D,UAAM,0BAA0B,yBAAyB;AAEzD,QAAI,CAAC,kCAAkC,CAAC,yBAAyB;AAC/D,aAAO;AAAA,IACR;AAED,UAAM,uBAAuB,aAAa;AAC1C,WAAO,gBAAgB,QAAQ,SAAS,oBAAoB;AAAA,EAC7D;AAED,SAAO,gBAAgB,QAAQ,SAAS,YAAY;AACtD;"}