@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueEnumValueNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { isEnumType } from '../../type/definition.mjs';\n\n/**\n * Unique enum value names\n *\n * A GraphQL enum type is only valid if all its values are uniquely named.\n */\nexport function UniqueEnumValueNamesRule(context) {\n  const schema = context.getSchema();\n  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);\n  const knownValueNames = Object.create(null);\n  return {\n    EnumTypeDefinition: checkValueUniqueness,\n    EnumTypeExtension: checkValueUniqueness,\n  };\n\n  function checkValueUniqueness(node) {\n    var _node$values;\n\n    const typeName = node.name.value;\n\n    if (!knownValueNames[typeName]) {\n      knownValueNames[typeName] = Object.create(null);\n    } // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n\n    const valueNodes =\n      (_node$values = node.values) !== null && _node$values !== void 0\n        ? _node$values\n        : [];\n    const valueNames = knownValueNames[typeName];\n\n    for (const valueDef of valueNodes) {\n      const valueName = valueDef.name.value;\n      const existingType = existingTypeMap[typeName];\n\n      if (isEnumType(existingType) && existingType.getValue(valueName)) {\n        context.reportError(\n          new GraphQLError(\n            `Enum value \"${typeName}.${valueName}\" already exists in the schema. It cannot also be defined in this type extension.`,\n            {\n              nodes: valueDef.name,\n            },\n          ),\n        );\n      } else if (valueNames[valueName]) {\n        context.reportError(\n          new GraphQLError(\n            `Enum value \"${typeName}.${valueName}\" can only be defined once.`,\n            {\n              nodes: [valueNames[valueName], valueDef.name],\n            },\n          ),\n        );\n      } else {\n        valueNames[valueName] = valueDef.name;\n      }\n    }\n\n    return false;\n  }\n}\n"],"names":[],"mappings":";;AAQO,SAAS,yBAAyB,SAAS;AAChD,QAAM,SAAS,QAAQ,UAAS;AAChC,QAAM,kBAAkB,SAAS,OAAO,WAAU,IAAK,uBAAO,OAAO,IAAI;AACzE,QAAM,kBAAkB,uBAAO,OAAO,IAAI;AAC1C,SAAO;AAAA,IACL,oBAAoB;AAAA,IACpB,mBAAmB;AAAA,EACvB;AAEE,WAAS,qBAAqB,MAAM;AAClC,QAAI;AAEJ,UAAM,WAAW,KAAK,KAAK;AAE3B,QAAI,CAAC,gBAAgB,QAAQ,GAAG;AAC9B,sBAAgB,QAAQ,IAAI,uBAAO,OAAO,IAAI;AAAA,IAChD;AAIA,UAAM,cACH,eAAe,KAAK,YAAY,QAAQ,iBAAiB,SACtD,eACA,CAAA;AACN,UAAM,aAAa,gBAAgB,QAAQ;AAE3C,eAAW,YAAY,YAAY;AACjC,YAAM,YAAY,SAAS,KAAK;AAChC,YAAM,eAAe,gBAAgB,QAAQ;AAE7C,UAAI,WAAW,YAAY,KAAK,aAAa,SAAS,SAAS,GAAG;AAChE,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,eAAe,QAAQ,IAAI,SAAS;AAAA,YACpC;AAAA,cACE,OAAO,SAAS;AAAA,YAC9B;AAAA,UACA;AAAA,QACA;AAAA,MACM,WAAW,WAAW,SAAS,GAAG;AAChC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,eAAe,QAAQ,IAAI,SAAS;AAAA,YACpC;AAAA,cACE,OAAO,CAAC,WAAW,SAAS,GAAG,SAAS,IAAI;AAAA,YAC1D;AAAA,UACA;AAAA,QACA;AAAA,MACM,OAAO;AACL,mBAAW,SAAS,IAAI,SAAS;AAAA,MACnC;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/validation/rules/UniqueFieldDefinitionNamesRule.js

@@ -0,0 +1,59 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { isObjectType, isInterfaceType, isInputObjectType } from "../../type/definition.js";
+function UniqueFieldDefinitionNamesRule(context) {
+  const schema = context.getSchema();
+  const existingTypeMap = schema ? schema.getTypeMap() : /* @__PURE__ */ Object.create(null);
+  const knownFieldNames = /* @__PURE__ */ Object.create(null);
+  return {
+    InputObjectTypeDefinition: checkFieldUniqueness,
+    InputObjectTypeExtension: checkFieldUniqueness,
+    InterfaceTypeDefinition: checkFieldUniqueness,
+    InterfaceTypeExtension: checkFieldUniqueness,
+    ObjectTypeDefinition: checkFieldUniqueness,
+    ObjectTypeExtension: checkFieldUniqueness
+  };
+  function checkFieldUniqueness(node) {
+    var _node$fields;
+    const typeName = node.name.value;
+    if (!knownFieldNames[typeName]) {
+      knownFieldNames[typeName] = /* @__PURE__ */ Object.create(null);
+    }
+    const fieldNodes = (_node$fields = node.fields) !== null && _node$fields !== void 0 ? _node$fields : [];
+    const fieldNames = knownFieldNames[typeName];
+    for (const fieldDef of fieldNodes) {
+      const fieldName = fieldDef.name.value;
+      if (hasField(existingTypeMap[typeName], fieldName)) {
+        context.reportError(
+          new GraphQLError(
+            `Field "${typeName}.${fieldName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            {
+              nodes: fieldDef.name
+            }
+          )
+        );
+      } else if (fieldNames[fieldName]) {
+        context.reportError(
+          new GraphQLError(
+            `Field "${typeName}.${fieldName}" can only be defined once.`,
+            {
+              nodes: [fieldNames[fieldName], fieldDef.name]
+            }
+          )
+        );
+      } else {
+        fieldNames[fieldName] = fieldDef.name;
+      }
+    }
+    return false;
+  }
+}
+function hasField(type, fieldName) {
+  if (isObjectType(type) || isInterfaceType(type) || isInputObjectType(type)) {
+    return type.getFields()[fieldName] != null;
+  }
+  return false;
+}
+export {
+  UniqueFieldDefinitionNamesRule
+};
+//# sourceMappingURL=UniqueFieldDefinitionNamesRule.js.map

package/dist/node_modules/graphql/validation/rules/UniqueFieldDefinitionNamesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueFieldDefinitionNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueFieldDefinitionNamesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport {\n  isInputObjectType,\n  isInterfaceType,\n  isObjectType,\n} from '../../type/definition.mjs';\n\n/**\n * Unique field definition names\n *\n * A GraphQL complex type is only valid if all its fields are uniquely named.\n */\nexport function UniqueFieldDefinitionNamesRule(context) {\n  const schema = context.getSchema();\n  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);\n  const knownFieldNames = Object.create(null);\n  return {\n    InputObjectTypeDefinition: checkFieldUniqueness,\n    InputObjectTypeExtension: checkFieldUniqueness,\n    InterfaceTypeDefinition: checkFieldUniqueness,\n    InterfaceTypeExtension: checkFieldUniqueness,\n    ObjectTypeDefinition: checkFieldUniqueness,\n    ObjectTypeExtension: checkFieldUniqueness,\n  };\n\n  function checkFieldUniqueness(node) {\n    var _node$fields;\n\n    const typeName = node.name.value;\n\n    if (!knownFieldNames[typeName]) {\n      knownFieldNames[typeName] = Object.create(null);\n    } // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n\n    const fieldNodes =\n      (_node$fields = node.fields) !== null && _node$fields !== void 0\n        ? _node$fields\n        : [];\n    const fieldNames = knownFieldNames[typeName];\n\n    for (const fieldDef of fieldNodes) {\n      const fieldName = fieldDef.name.value;\n\n      if (hasField(existingTypeMap[typeName], fieldName)) {\n        context.reportError(\n          new GraphQLError(\n            `Field \"${typeName}.${fieldName}\" already exists in the schema. It cannot also be defined in this type extension.`,\n            {\n              nodes: fieldDef.name,\n            },\n          ),\n        );\n      } else if (fieldNames[fieldName]) {\n        context.reportError(\n          new GraphQLError(\n            `Field \"${typeName}.${fieldName}\" can only be defined once.`,\n            {\n              nodes: [fieldNames[fieldName], fieldDef.name],\n            },\n          ),\n        );\n      } else {\n        fieldNames[fieldName] = fieldDef.name;\n      }\n    }\n\n    return false;\n  }\n}\n\nfunction hasField(type, fieldName) {\n  if (isObjectType(type) || isInterfaceType(type) || isInputObjectType(type)) {\n    return type.getFields()[fieldName] != null;\n  }\n\n  return false;\n}\n"],"names":[],"mappings":";;AAYO,SAAS,+BAA+B,SAAS;AACtD,QAAM,SAAS,QAAQ,UAAS;AAChC,QAAM,kBAAkB,SAAS,OAAO,WAAU,IAAK,uBAAO,OAAO,IAAI;AACzE,QAAM,kBAAkB,uBAAO,OAAO,IAAI;AAC1C,SAAO;AAAA,IACL,2BAA2B;AAAA,IAC3B,0BAA0B;AAAA,IAC1B,yBAAyB;AAAA,IACzB,wBAAwB;AAAA,IACxB,sBAAsB;AAAA,IACtB,qBAAqB;AAAA,EACzB;AAEE,WAAS,qBAAqB,MAAM;AAClC,QAAI;AAEJ,UAAM,WAAW,KAAK,KAAK;AAE3B,QAAI,CAAC,gBAAgB,QAAQ,GAAG;AAC9B,sBAAgB,QAAQ,IAAI,uBAAO,OAAO,IAAI;AAAA,IAChD;AAIA,UAAM,cACH,eAAe,KAAK,YAAY,QAAQ,iBAAiB,SACtD,eACA,CAAA;AACN,UAAM,aAAa,gBAAgB,QAAQ;AAE3C,eAAW,YAAY,YAAY;AACjC,YAAM,YAAY,SAAS,KAAK;AAEhC,UAAI,SAAS,gBAAgB,QAAQ,GAAG,SAAS,GAAG;AAClD,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,UAAU,QAAQ,IAAI,SAAS;AAAA,YAC/B;AAAA,cACE,OAAO,SAAS;AAAA,YAC9B;AAAA,UACA;AAAA,QACA;AAAA,MACM,WAAW,WAAW,SAAS,GAAG;AAChC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,UAAU,QAAQ,IAAI,SAAS;AAAA,YAC/B;AAAA,cACE,OAAO,CAAC,WAAW,SAAS,GAAG,SAAS,IAAI;AAAA,YAC1D;AAAA,UACA;AAAA,QACA;AAAA,MACM,OAAO;AACL,mBAAW,SAAS,IAAI,SAAS;AAAA,MACnC;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AAEA,SAAS,SAAS,MAAM,WAAW;AACjC,MAAI,aAAa,IAAI,KAAK,gBAAgB,IAAI,KAAK,kBAAkB,IAAI,GAAG;AAC1E,WAAO,KAAK,YAAY,SAAS,KAAK;AAAA,EACxC;AAEA,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/validation/rules/UniqueFragmentNamesRule.js

@@ -0,0 +1,27 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueFragmentNamesRule(context) {
+  const knownFragmentNames = /* @__PURE__ */ Object.create(null);
+  return {
+    OperationDefinition: () => false,
+    FragmentDefinition(node) {
+      const fragmentName = node.name.value;
+      if (knownFragmentNames[fragmentName]) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one fragment named "${fragmentName}".`,
+            {
+              nodes: [knownFragmentNames[fragmentName], node.name]
+            }
+          )
+        );
+      } else {
+        knownFragmentNames[fragmentName] = node.name;
+      }
+      return false;
+    }
+  };
+}
+export {
+  UniqueFragmentNamesRule
+};
+//# sourceMappingURL=UniqueFragmentNamesRule.js.map

package/dist/node_modules/graphql/validation/rules/UniqueFragmentNamesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueFragmentNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueFragmentNamesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique fragment names\n *\n * A GraphQL document is only valid if all defined fragments have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Fragment-Name-Uniqueness\n */\nexport function UniqueFragmentNamesRule(context) {\n  const knownFragmentNames = Object.create(null);\n  return {\n    OperationDefinition: () => false,\n\n    FragmentDefinition(node) {\n      const fragmentName = node.name.value;\n\n      if (knownFragmentNames[fragmentName]) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one fragment named \"${fragmentName}\".`,\n            {\n              nodes: [knownFragmentNames[fragmentName], node.name],\n            },\n          ),\n        );\n      } else {\n        knownFragmentNames[fragmentName] = node.name;\n      }\n\n      return false;\n    },\n  };\n}\n"],"names":[],"mappings":";AASO,SAAS,wBAAwB,SAAS;AAC/C,QAAM,qBAAqB,uBAAO,OAAO,IAAI;AAC7C,SAAO;AAAA,IACL,qBAAqB,MAAM;AAAA,IAE3B,mBAAmB,MAAM;AACvB,YAAM,eAAe,KAAK,KAAK;AAE/B,UAAI,mBAAmB,YAAY,GAAG;AACpC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,yCAAyC,YAAY;AAAA,YACrD;AAAA,cACE,OAAO,CAAC,mBAAmB,YAAY,GAAG,KAAK,IAAI;AAAA,YACjE;AAAA,UACA;AAAA,QACA;AAAA,MACM,OAAO;AACL,2BAAmB,YAAY,IAAI,KAAK;AAAA,MAC1C;AAEA,aAAO;AAAA,IACT;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/validation/rules/UniqueInputFieldNamesRule.js

@@ -0,0 +1,38 @@
+import { invariant } from "../../jsutils/invariant.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueInputFieldNamesRule(context) {
+  const knownNameStack = [];
+  let knownNames = /* @__PURE__ */ Object.create(null);
+  return {
+    ObjectValue: {
+      enter() {
+        knownNameStack.push(knownNames);
+        knownNames = /* @__PURE__ */ Object.create(null);
+      },
+      leave() {
+        const prevKnownNames = knownNameStack.pop();
+        prevKnownNames || invariant(false);
+        knownNames = prevKnownNames;
+      }
+    },
+    ObjectField(node) {
+      const fieldName = node.name.value;
+      if (knownNames[fieldName]) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one input field named "${fieldName}".`,
+            {
+              nodes: [knownNames[fieldName], node.name]
+            }
+          )
+        );
+      } else {
+        knownNames[fieldName] = node.name;
+      }
+    }
+  };
+}
+export {
+  UniqueInputFieldNamesRule
+};
+//# sourceMappingURL=UniqueInputFieldNamesRule.js.map

package/dist/node_modules/graphql/validation/rules/UniqueInputFieldNamesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueInputFieldNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueInputFieldNamesRule.mjs"],"sourcesContent":["import { invariant } from '../../jsutils/invariant.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique input field names\n *\n * A GraphQL input object value is only valid if all supplied fields are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Input-Object-Field-Uniqueness\n */\nexport function UniqueInputFieldNamesRule(context) {\n  const knownNameStack = [];\n  let knownNames = Object.create(null);\n  return {\n    ObjectValue: {\n      enter() {\n        knownNameStack.push(knownNames);\n        knownNames = Object.create(null);\n      },\n\n      leave() {\n        const prevKnownNames = knownNameStack.pop();\n        prevKnownNames || invariant(false);\n        knownNames = prevKnownNames;\n      },\n    },\n\n    ObjectField(node) {\n      const fieldName = node.name.value;\n\n      if (knownNames[fieldName]) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one input field named \"${fieldName}\".`,\n            {\n              nodes: [knownNames[fieldName], node.name],\n            },\n          ),\n        );\n      } else {\n        knownNames[fieldName] = node.name;\n      }\n    },\n  };\n}\n"],"names":[],"mappings":";;AAWO,SAAS,0BAA0B,SAAS;AACjD,QAAM,iBAAiB,CAAA;AACvB,MAAI,aAAa,uBAAO,OAAO,IAAI;AACnC,SAAO;AAAA,IACL,aAAa;AAAA,MACX,QAAQ;AACN,uBAAe,KAAK,UAAU;AAC9B,qBAAa,uBAAO,OAAO,IAAI;AAAA,MACjC;AAAA,MAEA,QAAQ;AACN,cAAM,iBAAiB,eAAe,IAAG;AACzC,0BAAkB,UAAU,KAAK;AACjC,qBAAa;AAAA,MACf;AAAA,IACN;AAAA,IAEI,YAAY,MAAM;AAChB,YAAM,YAAY,KAAK,KAAK;AAE5B,UAAI,WAAW,SAAS,GAAG;AACzB,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,4CAA4C,SAAS;AAAA,YACrD;AAAA,cACE,OAAO,CAAC,WAAW,SAAS,GAAG,KAAK,IAAI;AAAA,YACtD;AAAA,UACA;AAAA,QACA;AAAA,MACM,OAAO;AACL,mBAAW,SAAS,IAAI,KAAK;AAAA,MAC/B;AAAA,IACF;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/validation/rules/UniqueOperationNamesRule.js

@@ -0,0 +1,32 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueOperationNamesRule(context) {
+  const knownOperationNames = /* @__PURE__ */ Object.create(null);
+  return {
+    OperationDefinition(node) {
+      const operationName = node.name;
+      if (operationName) {
+        if (knownOperationNames[operationName.value]) {
+          context.reportError(
+            new GraphQLError(
+              `There can be only one operation named "${operationName.value}".`,
+              {
+                nodes: [
+                  knownOperationNames[operationName.value],
+                  operationName
+                ]
+              }
+            )
+          );
+        } else {
+          knownOperationNames[operationName.value] = operationName;
+        }
+      }
+      return false;
+    },
+    FragmentDefinition: () => false
+  };
+}
+export {
+  UniqueOperationNamesRule
+};
+//# sourceMappingURL=UniqueOperationNamesRule.js.map

package/dist/node_modules/graphql/validation/rules/UniqueOperationNamesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueOperationNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueOperationNamesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique operation names\n *\n * A GraphQL document is only valid if all defined operations have unique names.\n *\n * See https://spec.graphql.org/draft/#sec-Operation-Name-Uniqueness\n */\nexport function UniqueOperationNamesRule(context) {\n  const knownOperationNames = Object.create(null);\n  return {\n    OperationDefinition(node) {\n      const operationName = node.name;\n\n      if (operationName) {\n        if (knownOperationNames[operationName.value]) {\n          context.reportError(\n            new GraphQLError(\n              `There can be only one operation named \"${operationName.value}\".`,\n              {\n                nodes: [\n                  knownOperationNames[operationName.value],\n                  operationName,\n                ],\n              },\n            ),\n          );\n        } else {\n          knownOperationNames[operationName.value] = operationName;\n        }\n      }\n\n      return false;\n    },\n\n    FragmentDefinition: () => false,\n  };\n}\n"],"names":[],"mappings":";AASO,SAAS,yBAAyB,SAAS;AAChD,QAAM,sBAAsB,uBAAO,OAAO,IAAI;AAC9C,SAAO;AAAA,IACL,oBAAoB,MAAM;AACxB,YAAM,gBAAgB,KAAK;AAE3B,UAAI,eAAe;AACjB,YAAI,oBAAoB,cAAc,KAAK,GAAG;AAC5C,kBAAQ;AAAA,YACN,IAAI;AAAA,cACF,0CAA0C,cAAc,KAAK;AAAA,cAC7D;AAAA,gBACE,OAAO;AAAA,kBACL,oBAAoB,cAAc,KAAK;AAAA,kBACvC;AAAA,gBAClB;AAAA,cACA;AAAA,YACA;AAAA,UACA;AAAA,QACQ,OAAO;AACL,8BAAoB,cAAc,KAAK,IAAI;AAAA,QAC7C;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAAA,IAEA,oBAAoB,MAAM;AAAA,EAC9B;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/validation/rules/UniqueOperationTypesRule.js

@@ -0,0 +1,48 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueOperationTypesRule(context) {
+  const schema = context.getSchema();
+  const definedOperationTypes = /* @__PURE__ */ Object.create(null);
+  const existingOperationTypes = schema ? {
+    query: schema.getQueryType(),
+    mutation: schema.getMutationType(),
+    subscription: schema.getSubscriptionType()
+  } : {};
+  return {
+    SchemaDefinition: checkOperationTypes,
+    SchemaExtension: checkOperationTypes
+  };
+  function checkOperationTypes(node) {
+    var _node$operationTypes;
+    const operationTypesNodes = (_node$operationTypes = node.operationTypes) !== null && _node$operationTypes !== void 0 ? _node$operationTypes : [];
+    for (const operationType of operationTypesNodes) {
+      const operation = operationType.operation;
+      const alreadyDefinedOperationType = definedOperationTypes[operation];
+      if (existingOperationTypes[operation]) {
+        context.reportError(
+          new GraphQLError(
+            `Type for ${operation} already defined in the schema. It cannot be redefined.`,
+            {
+              nodes: operationType
+            }
+          )
+        );
+      } else if (alreadyDefinedOperationType) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one ${operation} type in schema.`,
+            {
+              nodes: [alreadyDefinedOperationType, operationType]
+            }
+          )
+        );
+      } else {
+        definedOperationTypes[operation] = operationType;
+      }
+    }
+    return false;
+  }
+}
+export {
+  UniqueOperationTypesRule
+};
+//# sourceMappingURL=UniqueOperationTypesRule.js.map

package/dist/node_modules/graphql/validation/rules/UniqueOperationTypesRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueOperationTypesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueOperationTypesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique operation types\n *\n * A GraphQL document is only valid if it has only one type per operation.\n */\nexport function UniqueOperationTypesRule(context) {\n  const schema = context.getSchema();\n  const definedOperationTypes = Object.create(null);\n  const existingOperationTypes = schema\n    ? {\n        query: schema.getQueryType(),\n        mutation: schema.getMutationType(),\n        subscription: schema.getSubscriptionType(),\n      }\n    : {};\n  return {\n    SchemaDefinition: checkOperationTypes,\n    SchemaExtension: checkOperationTypes,\n  };\n\n  function checkOperationTypes(node) {\n    var _node$operationTypes;\n\n    // See: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n    const operationTypesNodes =\n      (_node$operationTypes = node.operationTypes) !== null &&\n      _node$operationTypes !== void 0\n        ? _node$operationTypes\n        : [];\n\n    for (const operationType of operationTypesNodes) {\n      const operation = operationType.operation;\n      const alreadyDefinedOperationType = definedOperationTypes[operation];\n\n      if (existingOperationTypes[operation]) {\n        context.reportError(\n          new GraphQLError(\n            `Type for ${operation} already defined in the schema. It cannot be redefined.`,\n            {\n              nodes: operationType,\n            },\n          ),\n        );\n      } else if (alreadyDefinedOperationType) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one ${operation} type in schema.`,\n            {\n              nodes: [alreadyDefinedOperationType, operationType],\n            },\n          ),\n        );\n      } else {\n        definedOperationTypes[operation] = operationType;\n      }\n    }\n\n    return false;\n  }\n}\n"],"names":[],"mappings":";AAOO,SAAS,yBAAyB,SAAS;AAChD,QAAM,SAAS,QAAQ,UAAS;AAChC,QAAM,wBAAwB,uBAAO,OAAO,IAAI;AAChD,QAAM,yBAAyB,SAC3B;AAAA,IACE,OAAO,OAAO,aAAY;AAAA,IAC1B,UAAU,OAAO,gBAAe;AAAA,IAChC,cAAc,OAAO,oBAAmB;AAAA,EAChD,IACM,CAAA;AACJ,SAAO;AAAA,IACL,kBAAkB;AAAA,IAClB,iBAAiB;AAAA,EACrB;AAEE,WAAS,oBAAoB,MAAM;AACjC,QAAI;AAKJ,UAAM,uBACH,uBAAuB,KAAK,oBAAoB,QACjD,yBAAyB,SACrB,uBACA,CAAA;AAEN,eAAW,iBAAiB,qBAAqB;AAC/C,YAAM,YAAY,cAAc;AAChC,YAAM,8BAA8B,sBAAsB,SAAS;AAEnE,UAAI,uBAAuB,SAAS,GAAG;AACrC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,YAAY,SAAS;AAAA,YACrB;AAAA,cACE,OAAO;AAAA,YACrB;AAAA,UACA;AAAA,QACA;AAAA,MACM,WAAW,6BAA6B;AACtC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,yBAAyB,SAAS;AAAA,YAClC;AAAA,cACE,OAAO,CAAC,6BAA6B,aAAa;AAAA,YAChE;AAAA,UACA;AAAA,QACA;AAAA,MACM,OAAO;AACL,8BAAsB,SAAS,IAAI;AAAA,MACrC;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;","x_google_ignoreList":[0]}

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,UAAS;AAChC,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,QAAQ;AAAA,UACjB;AAAA,YACE,OAAO,KAAK;AAAA,UACxB;AAAA,QACA;AAAA,MACA;AACM;AAAA,IACF;AAEA,QAAI,eAAe,QAAQ,GAAG;AAC5B,cAAQ;AAAA,QACN,IAAI,aAAa,qCAAqC,QAAQ,MAAM;AAAA,UAClE,OAAO,CAAC,eAAe,QAAQ,GAAG,KAAK,IAAI;AAAA,QACrD,CAAS;AAAA,MACT;AAAA,IACI,OAAO;AACL,qBAAe,QAAQ,IAAI,KAAK;AAAA,IAClC;AAEA,WAAO;AAAA,EACT;AACF;","x_google_ignoreList":[0]}

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,CAAA;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,YAAY;AAAA,cACtD;AAAA,gBACE,OAAO,cAAc,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI;AAAA,cACrE;AAAA,YACA;AAAA,UACA;AAAA,QACQ;AAAA,MACF;AAAA,IACF;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,170 @@
+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 { Kind } from "../../language/kinds.js";
+import { print } from "../../language/printer.js";
+import { isNonNullType, getNamedType, isInputObjectType, isRequiredInputField, getNullableType, isListType, isLeafType } from "../../type/definition.js";
+function ValuesOfCorrectTypeRule(context) {
+  let variableDefinitions = {};
+  return {
+    OperationDefinition: {
+      enter() {
+        variableDefinitions = {};
+      }
+    },
+    VariableDefinition(definition) {
+      variableDefinitions[definition.variable.name.value] = definition;
+    },
+    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
+              }
+            )
+          );
+        }
+      }
+      if (type.isOneOf) {
+        validateOneOfInputObject(context, node, type, fieldNodeMap);
+      }
+    },
+    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
+          }
+        )
+      );
+    }
+  }
+}
+function validateOneOfInputObject(context, node, type, fieldNodeMap) {
+  var _fieldNodeMap$keys$;
+  const keys = Object.keys(fieldNodeMap);
+  const isNotExactlyOneField = keys.length !== 1;
+  if (isNotExactlyOneField) {
+    context.reportError(
+      new GraphQLError(
+        `OneOf Input Object "${type.name}" must specify exactly one key.`,
+        {
+          nodes: [node]
+        }
+      )
+    );
+    return;
+  }
+  const value = (_fieldNodeMap$keys$ = fieldNodeMap[keys[0]]) === null || _fieldNodeMap$keys$ === void 0 ? void 0 : _fieldNodeMap$keys$.value;
+  const isNullLiteral = !value || value.kind === Kind.NULL;
+  if (isNullLiteral) {
+    context.reportError(
+      new GraphQLError(`Field "${type.name}.${keys[0]}" must be non-null.`, {
+        nodes: [node]
+      })
+    );
+  }
+}
+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 { Kind } from '../../language/kinds.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  let variableDefinitions = {};\n  return {\n    OperationDefinition: {\n      enter() {\n        variableDefinitions = {};\n      },\n    },\n\n    VariableDefinition(definition) {\n      variableDefinitions[definition.variable.name.value] = definition;\n    },\n\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      if (type.isOneOf) {\n        validateOneOfInputObject(context, node, type, fieldNodeMap);\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\nfunction validateOneOfInputObject(context, node, type, fieldNodeMap) {\n  var _fieldNodeMap$keys$;\n\n  const keys = Object.keys(fieldNodeMap);\n  const isNotExactlyOneField = keys.length !== 1;\n\n  if (isNotExactlyOneField) {\n    context.reportError(\n      new GraphQLError(\n        `OneOf Input Object \"${type.name}\" must specify exactly one key.`,\n        {\n          nodes: [node],\n        },\n      ),\n    );\n    return;\n  }\n\n  const value =\n    (_fieldNodeMap$keys$ = fieldNodeMap[keys[0]]) === null ||\n    _fieldNodeMap$keys$ === void 0\n      ? void 0\n      : _fieldNodeMap$keys$.value;\n  const isNullLiteral = !value || value.kind === Kind.NULL;\n\n  if (isNullLiteral) {\n    context.reportError(\n      new GraphQLError(`Field \"${type.name}.${keys[0]}\" must be non-null.`, {\n        nodes: [node],\n      }),\n    );\n  }\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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,YAAY,+BAA+B,QAAQ;AAAA,YACjE;AAAA,cACE,OAAO,KAAK;AAAA,YAC1B;AAAA,UACA;AAAA,QACA;AAAA,MACM;AAAA,IACF;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,74 @@
+import { inspect } from "../../jsutils/inspect.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { isInputObjectType, isNullableType, 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, parentType } 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]
+                  }
+                )
+              );
+            }
+            if (isInputObjectType(parentType) && parentType.isOneOf && isNullableType(varType)) {
+              context.reportError(
+                new GraphQLError(
+                  `Variable "$${varName}" is of type "${varType}" but must be non-nullable to be used for OneOf Input Object "${parentType}".`,
+                  {
+                    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