@weavelogic/knowledge-graph-agent 0.4.0 → 0.6.0

package/dist/node_modules/graphql/utilities/typeComparators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeComparators.js","sources":["../../../../node_modules/graphql/utilities/typeComparators.mjs"],"sourcesContent":["import {\n  isAbstractType,\n  isInterfaceType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../type/definition.mjs';\n\n/**\n * Provided two types, return true if the types are equal (invariant).\n */\nexport function isEqualType(typeA, typeB) {\n  // Equivalent types are equal.\n  if (typeA === typeB) {\n    return true;\n  } // If either type is non-null, the other must also be non-null.\n\n  if (isNonNullType(typeA) && isNonNullType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  } // If either type is a list, the other must also be a list.\n\n  if (isListType(typeA) && isListType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  } // Otherwise the types are not equal.\n\n  return false;\n}\n/**\n * Provided a type and a super type, return true if the first type is either\n * equal or a subset of the second super type (covariant).\n */\n\nexport function isTypeSubTypeOf(schema, maybeSubType, superType) {\n  // Equivalent type is a valid subtype\n  if (maybeSubType === superType) {\n    return true;\n  } // If superType is non-null, maybeSubType must also be non-null.\n\n  if (isNonNullType(superType)) {\n    if (isNonNullType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n\n    return false;\n  }\n\n  if (isNonNullType(maybeSubType)) {\n    // If superType is nullable, maybeSubType may be non-null or nullable.\n    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);\n  } // If superType type is a list, maybeSubType type must also be a list.\n\n  if (isListType(superType)) {\n    if (isListType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n\n    return false;\n  }\n\n  if (isListType(maybeSubType)) {\n    // If superType is not a list, maybeSubType must also be not a list.\n    return false;\n  } // If superType type is an abstract type, check if it is super type of maybeSubType.\n  // Otherwise, the child type is not a valid subtype of the parent type.\n\n  return (\n    isAbstractType(superType) &&\n    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&\n    schema.isSubType(superType, maybeSubType)\n  );\n}\n/**\n * Provided two composite types, determine if they \"overlap\". Two composite\n * types overlap when the Sets of possible concrete types for each intersect.\n *\n * This is often used to determine if a fragment of a given type could possibly\n * be visited in a context of another type.\n *\n * This function is commutative.\n */\n\nexport function doTypesOverlap(schema, typeA, typeB) {\n  // Equivalent types overlap\n  if (typeA === typeB) {\n    return true;\n  }\n\n  if (isAbstractType(typeA)) {\n    if (isAbstractType(typeB)) {\n      // If both types are abstract, then determine if there is any intersection\n      // between possible concrete types of each.\n      return schema\n        .getPossibleTypes(typeA)\n        .some((type) => schema.isSubType(typeB, type));\n    } // Determine if the latter type is a possible concrete type of the former.\n\n    return schema.isSubType(typeA, typeB);\n  }\n\n  if (isAbstractType(typeB)) {\n    // Determine if the former type is a possible concrete type of the latter.\n    return schema.isSubType(typeB, typeA);\n  } // Otherwise the types do not overlap.\n\n  return false;\n}\n"],"names":[],"mappings":";AAWO,SAAS,YAAY,OAAO,OAAO;AAExC,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,KAAK,KAAK,cAAc,KAAK,GAAG;AAChD,WAAO,YAAY,MAAM,QAAQ,MAAM,MAAM;AAAA,EAC/C;AAEA,MAAI,WAAW,KAAK,KAAK,WAAW,KAAK,GAAG;AAC1C,WAAO,YAAY,MAAM,QAAQ,MAAM,MAAM;AAAA,EAC/C;AAEA,SAAO;AACT;AAMO,SAAS,gBAAgB,QAAQ,cAAc,WAAW;AAE/D,MAAI,iBAAiB,WAAW;AAC9B,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,SAAS,GAAG;AAC5B,QAAI,cAAc,YAAY,GAAG;AAC/B,aAAO,gBAAgB,QAAQ,aAAa,QAAQ,UAAU,MAAM;AAAA,IACtE;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,YAAY,GAAG;AAE/B,WAAO,gBAAgB,QAAQ,aAAa,QAAQ,SAAS;AAAA,EAC/D;AAEA,MAAI,WAAW,SAAS,GAAG;AACzB,QAAI,WAAW,YAAY,GAAG;AAC5B,aAAO,gBAAgB,QAAQ,aAAa,QAAQ,UAAU,MAAM;AAAA,IACtE;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,YAAY,GAAG;AAE5B,WAAO;AAAA,EACT;AAGA,SACE,eAAe,SAAS,MACvB,gBAAgB,YAAY,KAAK,aAAa,YAAY,MAC3D,OAAO,UAAU,WAAW,YAAY;AAE5C;AAWO,SAAS,eAAe,QAAQ,OAAO,OAAO;AAEnD,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACT;AAEA,MAAI,eAAe,KAAK,GAAG;AACzB,QAAI,eAAe,KAAK,GAAG;AAGzB,aAAO,OACJ,iBAAiB,KAAK,EACtB,KAAK,CAAC,SAAS,OAAO,UAAU,OAAO,IAAI,CAAC;AAAA,IACjD;AAEA,WAAO,OAAO,UAAU,OAAO,KAAK;AAAA,EACtC;AAEA,MAAI,eAAe,KAAK,GAAG;AAEzB,WAAO,OAAO,UAAU,OAAO,KAAK;AAAA,EACtC;AAEA,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/utilities/typeFromAST.js

@@ -0,0 +1,20 @@
+import { Kind } from "../language/kinds.js";
+import { GraphQLNonNull, GraphQLList } from "../type/definition.js";
+function typeFromAST(schema, typeNode) {
+  switch (typeNode.kind) {
+    case Kind.LIST_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new GraphQLList(innerType);
+    }
+    case Kind.NON_NULL_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new GraphQLNonNull(innerType);
+    }
+    case Kind.NAMED_TYPE:
+      return schema.getType(typeNode.name.value);
+  }
+}
+export {
+  typeFromAST
+};
+//# sourceMappingURL=typeFromAST.js.map

package/dist/node_modules/graphql/utilities/typeFromAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeFromAST.js","sources":["../../../../node_modules/graphql/utilities/typeFromAST.mjs"],"sourcesContent":["import { Kind } from '../language/kinds.mjs';\nimport { GraphQLList, GraphQLNonNull } from '../type/definition.mjs';\nexport function typeFromAST(schema, typeNode) {\n  switch (typeNode.kind) {\n    case Kind.LIST_TYPE: {\n      const innerType = typeFromAST(schema, typeNode.type);\n      return innerType && new GraphQLList(innerType);\n    }\n\n    case Kind.NON_NULL_TYPE: {\n      const innerType = typeFromAST(schema, typeNode.type);\n      return innerType && new GraphQLNonNull(innerType);\n    }\n\n    case Kind.NAMED_TYPE:\n      return schema.getType(typeNode.name.value);\n  }\n}\n"],"names":[],"mappings":";;AAEO,SAAS,YAAY,QAAQ,UAAU;AAC5C,UAAQ,SAAS,MAAI;AAAA,IACnB,KAAK,KAAK,WAAW;AACnB,YAAM,YAAY,YAAY,QAAQ,SAAS,IAAI;AACnD,aAAO,aAAa,IAAI,YAAY,SAAS;AAAA,IAC/C;AAAA,IAEA,KAAK,KAAK,eAAe;AACvB,YAAM,YAAY,YAAY,QAAQ,SAAS,IAAI;AACnD,aAAO,aAAa,IAAI,eAAe,SAAS;AAAA,IAClD;AAAA,IAEA,KAAK,KAAK;AACR,aAAO,OAAO,QAAQ,SAAS,KAAK,KAAK;AAAA,EAC/C;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/utilities/valueFromAST.js

@@ -0,0 +1,109 @@
+import { inspect } from "../jsutils/inspect.js";
+import { invariant } from "../jsutils/invariant.js";
+import { keyMap } from "../jsutils/keyMap.js";
+import { Kind } from "../language/kinds.js";
+import { isNonNullType, isListType, isInputObjectType, isLeafType } from "../type/definition.js";
+function valueFromAST(valueNode, type, variables) {
+  if (!valueNode) {
+    return;
+  }
+  if (valueNode.kind === Kind.VARIABLE) {
+    const variableName = valueNode.name.value;
+    if (variables == null || variables[variableName] === void 0) {
+      return;
+    }
+    const variableValue = variables[variableName];
+    if (variableValue === null && isNonNullType(type)) {
+      return;
+    }
+    return variableValue;
+  }
+  if (isNonNullType(type)) {
+    if (valueNode.kind === Kind.NULL) {
+      return;
+    }
+    return valueFromAST(valueNode, type.ofType, variables);
+  }
+  if (valueNode.kind === Kind.NULL) {
+    return null;
+  }
+  if (isListType(type)) {
+    const itemType = type.ofType;
+    if (valueNode.kind === Kind.LIST) {
+      const coercedValues = [];
+      for (const itemNode of valueNode.values) {
+        if (isMissingVariable(itemNode, variables)) {
+          if (isNonNullType(itemType)) {
+            return;
+          }
+          coercedValues.push(null);
+        } else {
+          const itemValue = valueFromAST(itemNode, itemType, variables);
+          if (itemValue === void 0) {
+            return;
+          }
+          coercedValues.push(itemValue);
+        }
+      }
+      return coercedValues;
+    }
+    const coercedValue = valueFromAST(valueNode, itemType, variables);
+    if (coercedValue === void 0) {
+      return;
+    }
+    return [coercedValue];
+  }
+  if (isInputObjectType(type)) {
+    if (valueNode.kind !== Kind.OBJECT) {
+      return;
+    }
+    const coercedObj = /* @__PURE__ */ Object.create(null);
+    const fieldNodes = keyMap(valueNode.fields, (field) => field.name.value);
+    for (const field of Object.values(type.getFields())) {
+      const fieldNode = fieldNodes[field.name];
+      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
+        if (field.defaultValue !== void 0) {
+          coercedObj[field.name] = field.defaultValue;
+        } else if (isNonNullType(field.type)) {
+          return;
+        }
+        continue;
+      }
+      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);
+      if (fieldValue === void 0) {
+        return;
+      }
+      coercedObj[field.name] = fieldValue;
+    }
+    if (type.isOneOf) {
+      const keys = Object.keys(coercedObj);
+      if (keys.length !== 1) {
+        return;
+      }
+      if (coercedObj[keys[0]] === null) {
+        return;
+      }
+    }
+    return coercedObj;
+  }
+  if (isLeafType(type)) {
+    let result;
+    try {
+      result = type.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return;
+    }
+    if (result === void 0) {
+      return;
+    }
+    return result;
+  }
+  invariant(false, "Unexpected input type: " + inspect(type));
+}
+function isMissingVariable(valueNode, variables) {
+  return valueNode.kind === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === void 0);
+}
+export {
+  valueFromAST
+};
+//# sourceMappingURL=valueFromAST.js.map

package/dist/node_modules/graphql/utilities/valueFromAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromAST.js","sources":["../../../../node_modules/graphql/utilities/valueFromAST.mjs"],"sourcesContent":["import { inspect } from '../jsutils/inspect.mjs';\nimport { invariant } from '../jsutils/invariant.mjs';\nimport { keyMap } from '../jsutils/keyMap.mjs';\nimport { Kind } from '../language/kinds.mjs';\nimport {\n  isInputObjectType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n} from '../type/definition.mjs';\n/**\n * Produces a JavaScript value given a GraphQL Value AST.\n *\n * A GraphQL type must be provided, which will be used to interpret different\n * GraphQL Value literals.\n *\n * Returns `undefined` when the value could not be validly coerced according to\n * the provided type.\n *\n * | GraphQL Value        | JSON Value    |\n * | -------------------- | ------------- |\n * | Input Object         | Object        |\n * | List                 | Array         |\n * | Boolean              | Boolean       |\n * | String               | String        |\n * | Int / Float          | Number        |\n * | Enum Value           | Unknown       |\n * | NullValue            | null          |\n *\n */\n\nexport function valueFromAST(valueNode, type, variables) {\n  if (!valueNode) {\n    // When there is no node, then there is also no value.\n    // Importantly, this is different from returning the value null.\n    return;\n  }\n\n  if (valueNode.kind === Kind.VARIABLE) {\n    const variableName = valueNode.name.value;\n\n    if (variables == null || variables[variableName] === undefined) {\n      // No valid return value.\n      return;\n    }\n\n    const variableValue = variables[variableName];\n\n    if (variableValue === null && isNonNullType(type)) {\n      return; // Invalid: intentionally return no value.\n    } // Note: This does no further checking that this variable is correct.\n    // This assumes that this query has been validated and the variable\n    // usage here is of the correct type.\n\n    return variableValue;\n  }\n\n  if (isNonNullType(type)) {\n    if (valueNode.kind === Kind.NULL) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return valueFromAST(valueNode, type.ofType, variables);\n  }\n\n  if (valueNode.kind === Kind.NULL) {\n    // This is explicitly returning the value null.\n    return null;\n  }\n\n  if (isListType(type)) {\n    const itemType = type.ofType;\n\n    if (valueNode.kind === Kind.LIST) {\n      const coercedValues = [];\n\n      for (const itemNode of valueNode.values) {\n        if (isMissingVariable(itemNode, variables)) {\n          // If an array contains a missing variable, it is either coerced to\n          // null or if the item type is non-null, it considered invalid.\n          if (isNonNullType(itemType)) {\n            return; // Invalid: intentionally return no value.\n          }\n\n          coercedValues.push(null);\n        } else {\n          const itemValue = valueFromAST(itemNode, itemType, variables);\n\n          if (itemValue === undefined) {\n            return; // Invalid: intentionally return no value.\n          }\n\n          coercedValues.push(itemValue);\n        }\n      }\n\n      return coercedValues;\n    }\n\n    const coercedValue = valueFromAST(valueNode, itemType, variables);\n\n    if (coercedValue === undefined) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return [coercedValue];\n  }\n\n  if (isInputObjectType(type)) {\n    if (valueNode.kind !== Kind.OBJECT) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    const coercedObj = Object.create(null);\n    const fieldNodes = keyMap(valueNode.fields, (field) => field.name.value);\n\n    for (const field of Object.values(type.getFields())) {\n      const fieldNode = fieldNodes[field.name];\n\n      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {\n        if (field.defaultValue !== undefined) {\n          coercedObj[field.name] = field.defaultValue;\n        } else if (isNonNullType(field.type)) {\n          return; // Invalid: intentionally return no value.\n        }\n\n        continue;\n      }\n\n      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);\n\n      if (fieldValue === undefined) {\n        return; // Invalid: intentionally return no value.\n      }\n\n      coercedObj[field.name] = fieldValue;\n    }\n\n    if (type.isOneOf) {\n      const keys = Object.keys(coercedObj);\n\n      if (keys.length !== 1) {\n        return; // Invalid: not exactly one key, intentionally return no value.\n      }\n\n      if (coercedObj[keys[0]] === null) {\n        return; // Invalid: value not non-null, intentionally return no value.\n      }\n    }\n\n    return coercedObj;\n  }\n\n  if (isLeafType(type)) {\n    // Scalars and Enums fulfill parsing a literal value via parseLiteral().\n    // Invalid values represent a failure to parse correctly, in which case\n    // no value is returned.\n    let result;\n\n    try {\n      result = type.parseLiteral(valueNode, variables);\n    } catch (_error) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    if (result === undefined) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return result;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable, all possible input types have been considered.\n\n  false || invariant(false, 'Unexpected input type: ' + inspect(type));\n} // Returns true if the provided valueNode is a variable which is not defined\n// in the set of variables.\n\nfunction isMissingVariable(valueNode, variables) {\n  return (\n    valueNode.kind === Kind.VARIABLE &&\n    (variables == null || variables[valueNode.name.value] === undefined)\n  );\n}\n"],"names":[],"mappings":";;;;;AA+BO,SAAS,aAAa,WAAW,MAAM,WAAW;AACvD,MAAI,CAAC,WAAW;AAGd;AAAA,EACF;AAEA,MAAI,UAAU,SAAS,KAAK,UAAU;AACpC,UAAM,eAAe,UAAU,KAAK;AAEpC,QAAI,aAAa,QAAQ,UAAU,YAAY,MAAM,QAAW;AAE9D;AAAA,IACF;AAEA,UAAM,gBAAgB,UAAU,YAAY;AAE5C,QAAI,kBAAkB,QAAQ,cAAc,IAAI,GAAG;AACjD;AAAA,IACF;AAIA,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,IAAI,GAAG;AACvB,QAAI,UAAU,SAAS,KAAK,MAAM;AAChC;AAAA,IACF;AAEA,WAAO,aAAa,WAAW,KAAK,QAAQ,SAAS;AAAA,EACvD;AAEA,MAAI,UAAU,SAAS,KAAK,MAAM;AAEhC,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,IAAI,GAAG;AACpB,UAAM,WAAW,KAAK;AAEtB,QAAI,UAAU,SAAS,KAAK,MAAM;AAChC,YAAM,gBAAgB,CAAA;AAEtB,iBAAW,YAAY,UAAU,QAAQ;AACvC,YAAI,kBAAkB,UAAU,SAAS,GAAG;AAG1C,cAAI,cAAc,QAAQ,GAAG;AAC3B;AAAA,UACF;AAEA,wBAAc,KAAK,IAAI;AAAA,QACzB,OAAO;AACL,gBAAM,YAAY,aAAa,UAAU,UAAU,SAAS;AAE5D,cAAI,cAAc,QAAW;AAC3B;AAAA,UACF;AAEA,wBAAc,KAAK,SAAS;AAAA,QAC9B;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAEA,UAAM,eAAe,aAAa,WAAW,UAAU,SAAS;AAEhE,QAAI,iBAAiB,QAAW;AAC9B;AAAA,IACF;AAEA,WAAO,CAAC,YAAY;AAAA,EACtB;AAEA,MAAI,kBAAkB,IAAI,GAAG;AAC3B,QAAI,UAAU,SAAS,KAAK,QAAQ;AAClC;AAAA,IACF;AAEA,UAAM,aAAa,uBAAO,OAAO,IAAI;AACrC,UAAM,aAAa,OAAO,UAAU,QAAQ,CAAC,UAAU,MAAM,KAAK,KAAK;AAEvE,eAAW,SAAS,OAAO,OAAO,KAAK,UAAS,CAAE,GAAG;AACnD,YAAM,YAAY,WAAW,MAAM,IAAI;AAEvC,UAAI,CAAC,aAAa,kBAAkB,UAAU,OAAO,SAAS,GAAG;AAC/D,YAAI,MAAM,iBAAiB,QAAW;AACpC,qBAAW,MAAM,IAAI,IAAI,MAAM;AAAA,QACjC,WAAW,cAAc,MAAM,IAAI,GAAG;AACpC;AAAA,QACF;AAEA;AAAA,MACF;AAEA,YAAM,aAAa,aAAa,UAAU,OAAO,MAAM,MAAM,SAAS;AAEtE,UAAI,eAAe,QAAW;AAC5B;AAAA,MACF;AAEA,iBAAW,MAAM,IAAI,IAAI;AAAA,IAC3B;AAEA,QAAI,KAAK,SAAS;AAChB,YAAM,OAAO,OAAO,KAAK,UAAU;AAEnC,UAAI,KAAK,WAAW,GAAG;AACrB;AAAA,MACF;AAEA,UAAI,WAAW,KAAK,CAAC,CAAC,MAAM,MAAM;AAChC;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,IAAI,GAAG;AAIpB,QAAI;AAEJ,QAAI;AACF,eAAS,KAAK,aAAa,WAAW,SAAS;AAAA,IACjD,SAAS,QAAQ;AACf;AAAA,IACF;AAEA,QAAI,WAAW,QAAW;AACxB;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAIS,YAAU,OAAO,4BAA4B,QAAQ,IAAI,CAAC;AACrE;AAGA,SAAS,kBAAkB,WAAW,WAAW;AAC/C,SACE,UAAU,SAAS,KAAK,aACvB,aAAa,QAAQ,UAAU,UAAU,KAAK,KAAK,MAAM;AAE9D;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/utilities/valueFromASTUntyped.js

@@ -0,0 +1,32 @@
+import { keyValMap } from "../jsutils/keyValMap.js";
+import { Kind } from "../language/kinds.js";
+function valueFromASTUntyped(valueNode, variables) {
+  switch (valueNode.kind) {
+    case Kind.NULL:
+      return null;
+    case Kind.INT:
+      return parseInt(valueNode.value, 10);
+    case Kind.FLOAT:
+      return parseFloat(valueNode.value);
+    case Kind.STRING:
+    case Kind.ENUM:
+    case Kind.BOOLEAN:
+      return valueNode.value;
+    case Kind.LIST:
+      return valueNode.values.map(
+        (node) => valueFromASTUntyped(node, variables)
+      );
+    case Kind.OBJECT:
+      return keyValMap(
+        valueNode.fields,
+        (field) => field.name.value,
+        (field) => valueFromASTUntyped(field.value, variables)
+      );
+    case Kind.VARIABLE:
+      return variables === null || variables === void 0 ? void 0 : variables[valueNode.name.value];
+  }
+}
+export {
+  valueFromASTUntyped
+};
+//# sourceMappingURL=valueFromASTUntyped.js.map

package/dist/node_modules/graphql/utilities/valueFromASTUntyped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromASTUntyped.js","sources":["../../../../node_modules/graphql/utilities/valueFromASTUntyped.mjs"],"sourcesContent":["import { keyValMap } from '../jsutils/keyValMap.mjs';\nimport { Kind } from '../language/kinds.mjs';\n/**\n * Produces a JavaScript value given a GraphQL Value AST.\n *\n * Unlike `valueFromAST()`, no type is provided. The resulting JavaScript value\n * will reflect the provided GraphQL value AST.\n *\n * | GraphQL Value        | JavaScript Value |\n * | -------------------- | ---------------- |\n * | Input Object         | Object           |\n * | List                 | Array            |\n * | Boolean              | Boolean          |\n * | String / Enum        | String           |\n * | Int / Float          | Number           |\n * | Null                 | null             |\n *\n */\n\nexport function valueFromASTUntyped(valueNode, variables) {\n  switch (valueNode.kind) {\n    case Kind.NULL:\n      return null;\n\n    case Kind.INT:\n      return parseInt(valueNode.value, 10);\n\n    case Kind.FLOAT:\n      return parseFloat(valueNode.value);\n\n    case Kind.STRING:\n    case Kind.ENUM:\n    case Kind.BOOLEAN:\n      return valueNode.value;\n\n    case Kind.LIST:\n      return valueNode.values.map((node) =>\n        valueFromASTUntyped(node, variables),\n      );\n\n    case Kind.OBJECT:\n      return keyValMap(\n        valueNode.fields,\n        (field) => field.name.value,\n        (field) => valueFromASTUntyped(field.value, variables),\n      );\n\n    case Kind.VARIABLE:\n      return variables === null || variables === void 0\n        ? void 0\n        : variables[valueNode.name.value];\n  }\n}\n"],"names":[],"mappings":";;AAmBO,SAAS,oBAAoB,WAAW,WAAW;AACxD,UAAQ,UAAU,MAAI;AAAA,IACpB,KAAK,KAAK;AACR,aAAO;AAAA,IAET,KAAK,KAAK;AACR,aAAO,SAAS,UAAU,OAAO,EAAE;AAAA,IAErC,KAAK,KAAK;AACR,aAAO,WAAW,UAAU,KAAK;AAAA,IAEnC,KAAK,KAAK;AAAA,IACV,KAAK,KAAK;AAAA,IACV,KAAK,KAAK;AACR,aAAO,UAAU;AAAA,IAEnB,KAAK,KAAK;AACR,aAAO,UAAU,OAAO;AAAA,QAAI,CAAC,SAC3B,oBAAoB,MAAM,SAAS;AAAA,MAC3C;AAAA,IAEI,KAAK,KAAK;AACR,aAAO;AAAA,QACL,UAAU;AAAA,QACV,CAAC,UAAU,MAAM,KAAK;AAAA,QACtB,CAAC,UAAU,oBAAoB,MAAM,OAAO,SAAS;AAAA,MAC7D;AAAA,IAEI,KAAK,KAAK;AACR,aAAO,cAAc,QAAQ,cAAc,SACvC,SACA,UAAU,UAAU,KAAK,KAAK;AAAA,EACxC;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/graphql/validation/ValidationContext.js

@@ -0,0 +1,171 @@
+import { Kind } from "../language/kinds.js";
+import { visit } from "../language/visitor.js";
+import { TypeInfo, visitWithTypeInfo } from "../utilities/TypeInfo.js";
+class ASTValidationContext {
+  constructor(ast, onError) {
+    this._ast = ast;
+    this._fragments = void 0;
+    this._fragmentSpreads = /* @__PURE__ */ new Map();
+    this._recursivelyReferencedFragments = /* @__PURE__ */ new Map();
+    this._onError = onError;
+  }
+  get [Symbol.toStringTag]() {
+    return "ASTValidationContext";
+  }
+  reportError(error) {
+    this._onError(error);
+  }
+  getDocument() {
+    return this._ast;
+  }
+  getFragment(name) {
+    let fragments;
+    if (this._fragments) {
+      fragments = this._fragments;
+    } else {
+      fragments = /* @__PURE__ */ Object.create(null);
+      for (const defNode of this.getDocument().definitions) {
+        if (defNode.kind === Kind.FRAGMENT_DEFINITION) {
+          fragments[defNode.name.value] = defNode;
+        }
+      }
+      this._fragments = fragments;
+    }
+    return fragments[name];
+  }
+  getFragmentSpreads(node) {
+    let spreads = this._fragmentSpreads.get(node);
+    if (!spreads) {
+      spreads = [];
+      const setsToVisit = [node];
+      let set;
+      while (set = setsToVisit.pop()) {
+        for (const selection of set.selections) {
+          if (selection.kind === Kind.FRAGMENT_SPREAD) {
+            spreads.push(selection);
+          } else if (selection.selectionSet) {
+            setsToVisit.push(selection.selectionSet);
+          }
+        }
+      }
+      this._fragmentSpreads.set(node, spreads);
+    }
+    return spreads;
+  }
+  getRecursivelyReferencedFragments(operation) {
+    let fragments = this._recursivelyReferencedFragments.get(operation);
+    if (!fragments) {
+      fragments = [];
+      const collectedNames = /* @__PURE__ */ Object.create(null);
+      const nodesToVisit = [operation.selectionSet];
+      let node;
+      while (node = nodesToVisit.pop()) {
+        for (const spread of this.getFragmentSpreads(node)) {
+          const fragName = spread.name.value;
+          if (collectedNames[fragName] !== true) {
+            collectedNames[fragName] = true;
+            const fragment = this.getFragment(fragName);
+            if (fragment) {
+              fragments.push(fragment);
+              nodesToVisit.push(fragment.selectionSet);
+            }
+          }
+        }
+      }
+      this._recursivelyReferencedFragments.set(operation, fragments);
+    }
+    return fragments;
+  }
+}
+class SDLValidationContext extends ASTValidationContext {
+  constructor(ast, schema, onError) {
+    super(ast, onError);
+    this._schema = schema;
+  }
+  get [Symbol.toStringTag]() {
+    return "SDLValidationContext";
+  }
+  getSchema() {
+    return this._schema;
+  }
+}
+class ValidationContext extends ASTValidationContext {
+  constructor(schema, ast, typeInfo, onError) {
+    super(ast, onError);
+    this._schema = schema;
+    this._typeInfo = typeInfo;
+    this._variableUsages = /* @__PURE__ */ new Map();
+    this._recursiveVariableUsages = /* @__PURE__ */ new Map();
+  }
+  get [Symbol.toStringTag]() {
+    return "ValidationContext";
+  }
+  getSchema() {
+    return this._schema;
+  }
+  getVariableUsages(node) {
+    let usages = this._variableUsages.get(node);
+    if (!usages) {
+      const newUsages = [];
+      const typeInfo = new TypeInfo(this._schema);
+      visit(
+        node,
+        visitWithTypeInfo(typeInfo, {
+          VariableDefinition: () => false,
+          Variable(variable) {
+            newUsages.push({
+              node: variable,
+              type: typeInfo.getInputType(),
+              defaultValue: typeInfo.getDefaultValue(),
+              parentType: typeInfo.getParentInputType()
+            });
+          }
+        })
+      );
+      usages = newUsages;
+      this._variableUsages.set(node, usages);
+    }
+    return usages;
+  }
+  getRecursiveVariableUsages(operation) {
+    let usages = this._recursiveVariableUsages.get(operation);
+    if (!usages) {
+      usages = this.getVariableUsages(operation);
+      for (const frag of this.getRecursivelyReferencedFragments(operation)) {
+        usages = usages.concat(this.getVariableUsages(frag));
+      }
+      this._recursiveVariableUsages.set(operation, usages);
+    }
+    return usages;
+  }
+  getType() {
+    return this._typeInfo.getType();
+  }
+  getParentType() {
+    return this._typeInfo.getParentType();
+  }
+  getInputType() {
+    return this._typeInfo.getInputType();
+  }
+  getParentInputType() {
+    return this._typeInfo.getParentInputType();
+  }
+  getFieldDef() {
+    return this._typeInfo.getFieldDef();
+  }
+  getDirective() {
+    return this._typeInfo.getDirective();
+  }
+  getArgument() {
+    return this._typeInfo.getArgument();
+  }
+  getEnumValue() {
+    return this._typeInfo.getEnumValue();
+  }
+}
+export {
+  ASTValidationContext,
+  SDLValidationContext,
+  ValidationContext
+};
+//# sourceMappingURL=ValidationContext.js.map

package/dist/node_modules/graphql/validation/ValidationContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationContext.js","sources":["../../../../node_modules/graphql/validation/ValidationContext.mjs"],"sourcesContent":["import { Kind } from '../language/kinds.mjs';\nimport { visit } from '../language/visitor.mjs';\nimport { TypeInfo, visitWithTypeInfo } from '../utilities/TypeInfo.mjs';\n\n/**\n * An instance of this class is passed as the \"this\" context to all validators,\n * allowing access to commonly useful contextual information from within a\n * validation rule.\n */\nexport class ASTValidationContext {\n  constructor(ast, onError) {\n    this._ast = ast;\n    this._fragments = undefined;\n    this._fragmentSpreads = new Map();\n    this._recursivelyReferencedFragments = new Map();\n    this._onError = onError;\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'ASTValidationContext';\n  }\n\n  reportError(error) {\n    this._onError(error);\n  }\n\n  getDocument() {\n    return this._ast;\n  }\n\n  getFragment(name) {\n    let fragments;\n\n    if (this._fragments) {\n      fragments = this._fragments;\n    } else {\n      fragments = Object.create(null);\n\n      for (const defNode of this.getDocument().definitions) {\n        if (defNode.kind === Kind.FRAGMENT_DEFINITION) {\n          fragments[defNode.name.value] = defNode;\n        }\n      }\n\n      this._fragments = fragments;\n    }\n\n    return fragments[name];\n  }\n\n  getFragmentSpreads(node) {\n    let spreads = this._fragmentSpreads.get(node);\n\n    if (!spreads) {\n      spreads = [];\n      const setsToVisit = [node];\n      let set;\n\n      while ((set = setsToVisit.pop())) {\n        for (const selection of set.selections) {\n          if (selection.kind === Kind.FRAGMENT_SPREAD) {\n            spreads.push(selection);\n          } else if (selection.selectionSet) {\n            setsToVisit.push(selection.selectionSet);\n          }\n        }\n      }\n\n      this._fragmentSpreads.set(node, spreads);\n    }\n\n    return spreads;\n  }\n\n  getRecursivelyReferencedFragments(operation) {\n    let fragments = this._recursivelyReferencedFragments.get(operation);\n\n    if (!fragments) {\n      fragments = [];\n      const collectedNames = Object.create(null);\n      const nodesToVisit = [operation.selectionSet];\n      let node;\n\n      while ((node = nodesToVisit.pop())) {\n        for (const spread of this.getFragmentSpreads(node)) {\n          const fragName = spread.name.value;\n\n          if (collectedNames[fragName] !== true) {\n            collectedNames[fragName] = true;\n            const fragment = this.getFragment(fragName);\n\n            if (fragment) {\n              fragments.push(fragment);\n              nodesToVisit.push(fragment.selectionSet);\n            }\n          }\n        }\n      }\n\n      this._recursivelyReferencedFragments.set(operation, fragments);\n    }\n\n    return fragments;\n  }\n}\nexport class SDLValidationContext extends ASTValidationContext {\n  constructor(ast, schema, onError) {\n    super(ast, onError);\n    this._schema = schema;\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'SDLValidationContext';\n  }\n\n  getSchema() {\n    return this._schema;\n  }\n}\nexport class ValidationContext extends ASTValidationContext {\n  constructor(schema, ast, typeInfo, onError) {\n    super(ast, onError);\n    this._schema = schema;\n    this._typeInfo = typeInfo;\n    this._variableUsages = new Map();\n    this._recursiveVariableUsages = new Map();\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'ValidationContext';\n  }\n\n  getSchema() {\n    return this._schema;\n  }\n\n  getVariableUsages(node) {\n    let usages = this._variableUsages.get(node);\n\n    if (!usages) {\n      const newUsages = [];\n      const typeInfo = new TypeInfo(this._schema);\n      visit(\n        node,\n        visitWithTypeInfo(typeInfo, {\n          VariableDefinition: () => false,\n\n          Variable(variable) {\n            newUsages.push({\n              node: variable,\n              type: typeInfo.getInputType(),\n              defaultValue: typeInfo.getDefaultValue(),\n              parentType: typeInfo.getParentInputType(),\n            });\n          },\n        }),\n      );\n      usages = newUsages;\n\n      this._variableUsages.set(node, usages);\n    }\n\n    return usages;\n  }\n\n  getRecursiveVariableUsages(operation) {\n    let usages = this._recursiveVariableUsages.get(operation);\n\n    if (!usages) {\n      usages = this.getVariableUsages(operation);\n\n      for (const frag of this.getRecursivelyReferencedFragments(operation)) {\n        usages = usages.concat(this.getVariableUsages(frag));\n      }\n\n      this._recursiveVariableUsages.set(operation, usages);\n    }\n\n    return usages;\n  }\n\n  getType() {\n    return this._typeInfo.getType();\n  }\n\n  getParentType() {\n    return this._typeInfo.getParentType();\n  }\n\n  getInputType() {\n    return this._typeInfo.getInputType();\n  }\n\n  getParentInputType() {\n    return this._typeInfo.getParentInputType();\n  }\n\n  getFieldDef() {\n    return this._typeInfo.getFieldDef();\n  }\n\n  getDirective() {\n    return this._typeInfo.getDirective();\n  }\n\n  getArgument() {\n    return this._typeInfo.getArgument();\n  }\n\n  getEnumValue() {\n    return this._typeInfo.getEnumValue();\n  }\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,24 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { isExecutableDefinitionNode } from "../../language/predicates.js";
+function ExecutableDefinitionsRule(context) {
+  return {
+    Document(node) {
+      for (const definition of node.definitions) {
+        if (!isExecutableDefinitionNode(definition)) {
+          const defName = definition.kind === Kind.SCHEMA_DEFINITION || definition.kind === Kind.SCHEMA_EXTENSION ? "schema" : '"' + definition.name.value + '"';
+          context.reportError(
+            new GraphQLError(`The ${defName} definition is not executable.`, {
+              nodes: definition
+            })
+          );
+        }
+      }
+      return false;
+    }
+  };
+}
+export {
+  ExecutableDefinitionsRule
+};
+//# sourceMappingURL=ExecutableDefinitionsRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutableDefinitionsRule.js","sources":["../../../../../node_modules/graphql/validation/rules/ExecutableDefinitionsRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { isExecutableDefinitionNode } from '../../language/predicates.mjs';\n\n/**\n * Executable definitions\n *\n * A GraphQL document is only valid for execution if all definitions are either\n * operation or fragment definitions.\n *\n * See https://spec.graphql.org/draft/#sec-Executable-Definitions\n */\nexport function ExecutableDefinitionsRule(context) {\n  return {\n    Document(node) {\n      for (const definition of node.definitions) {\n        if (!isExecutableDefinitionNode(definition)) {\n          const defName =\n            definition.kind === Kind.SCHEMA_DEFINITION ||\n            definition.kind === Kind.SCHEMA_EXTENSION\n              ? 'schema'\n              : '\"' + definition.name.value + '\"';\n          context.reportError(\n            new GraphQLError(`The ${defName} definition is not executable.`, {\n              nodes: definition,\n            }),\n          );\n        }\n      }\n\n      return false;\n    },\n  };\n}\n"],"names":[],"mappings":";;;AAYO,SAAS,0BAA0B,SAAS;AACjD,SAAO;AAAA,IACL,SAAS,MAAM;AACb,iBAAW,cAAc,KAAK,aAAa;AACzC,YAAI,CAAC,2BAA2B,UAAU,GAAG;AAC3C,gBAAM,UACJ,WAAW,SAAS,KAAK,qBACzB,WAAW,SAAS,KAAK,mBACrB,WACA,MAAM,WAAW,KAAK,QAAQ;AACpC,kBAAQ;AAAA,YACN,IAAI,aAAa,OAAO,OAAO,kCAAkC;AAAA,cAC/D,OAAO;AAAA,YACrB,CAAa;AAAA,UACb;AAAA,QACQ;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,80 @@
+import { didYouMean } from "../../jsutils/didYouMean.js";
+import { naturalCompare } from "../../jsutils/naturalCompare.js";
+import { suggestionList } from "../../jsutils/suggestionList.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { isAbstractType, isInterfaceType, isObjectType } from "../../type/definition.js";
+function FieldsOnCorrectTypeRule(context) {
+  return {
+    Field(node) {
+      const type = context.getParentType();
+      if (type) {
+        const fieldDef = context.getFieldDef();
+        if (!fieldDef) {
+          const schema = context.getSchema();
+          const fieldName = node.name.value;
+          let suggestion = didYouMean(
+            "to use an inline fragment on",
+            getSuggestedTypeNames(schema, type, fieldName)
+          );
+          if (suggestion === "") {
+            suggestion = didYouMean(getSuggestedFieldNames(type, fieldName));
+          }
+          context.reportError(
+            new GraphQLError(
+              `Cannot query field "${fieldName}" on type "${type.name}".` + suggestion,
+              {
+                nodes: node
+              }
+            )
+          );
+        }
+      }
+    }
+  };
+}
+function getSuggestedTypeNames(schema, type, fieldName) {
+  if (!isAbstractType(type)) {
+    return [];
+  }
+  const suggestedTypes = /* @__PURE__ */ new Set();
+  const usageCount = /* @__PURE__ */ Object.create(null);
+  for (const possibleType of schema.getPossibleTypes(type)) {
+    if (!possibleType.getFields()[fieldName]) {
+      continue;
+    }
+    suggestedTypes.add(possibleType);
+    usageCount[possibleType.name] = 1;
+    for (const possibleInterface of possibleType.getInterfaces()) {
+      var _usageCount$possibleI;
+      if (!possibleInterface.getFields()[fieldName]) {
+        continue;
+      }
+      suggestedTypes.add(possibleInterface);
+      usageCount[possibleInterface.name] = ((_usageCount$possibleI = usageCount[possibleInterface.name]) !== null && _usageCount$possibleI !== void 0 ? _usageCount$possibleI : 0) + 1;
+    }
+  }
+  return [...suggestedTypes].sort((typeA, typeB) => {
+    const usageCountDiff = usageCount[typeB.name] - usageCount[typeA.name];
+    if (usageCountDiff !== 0) {
+      return usageCountDiff;
+    }
+    if (isInterfaceType(typeA) && schema.isSubType(typeA, typeB)) {
+      return -1;
+    }
+    if (isInterfaceType(typeB) && schema.isSubType(typeB, typeA)) {
+      return 1;
+    }
+    return naturalCompare(typeA.name, typeB.name);
+  }).map((x) => x.name);
+}
+function getSuggestedFieldNames(type, fieldName) {
+  if (isObjectType(type) || isInterfaceType(type)) {
+    const possibleFieldNames = Object.keys(type.getFields());
+    return suggestionList(fieldName, possibleFieldNames);
+  }
+  return [];
+}
+export {
+  FieldsOnCorrectTypeRule
+};
+//# sourceMappingURL=FieldsOnCorrectTypeRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FieldsOnCorrectTypeRule.js","sources":["../../../../../node_modules/graphql/validation/rules/FieldsOnCorrectTypeRule.mjs"],"sourcesContent":["import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { naturalCompare } from '../../jsutils/naturalCompare.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport {\n  isAbstractType,\n  isInterfaceType,\n  isObjectType,\n} from '../../type/definition.mjs';\n\n/**\n * Fields on correct type\n *\n * A GraphQL document is only valid if all fields selected are defined by the\n * parent type, or are an allowed meta field such as __typename.\n *\n * See https://spec.graphql.org/draft/#sec-Field-Selections\n */\nexport function FieldsOnCorrectTypeRule(context) {\n  return {\n    Field(node) {\n      const type = context.getParentType();\n\n      if (type) {\n        const fieldDef = context.getFieldDef();\n\n        if (!fieldDef) {\n          // This field doesn't exist, lets look for suggestions.\n          const schema = context.getSchema();\n          const fieldName = node.name.value; // First determine if there are any suggested types to condition on.\n\n          let suggestion = didYouMean(\n            'to use an inline fragment on',\n            getSuggestedTypeNames(schema, type, fieldName),\n          ); // If there are no suggested types, then perhaps this was a typo?\n\n          if (suggestion === '') {\n            suggestion = didYouMean(getSuggestedFieldNames(type, fieldName));\n          } // Report an error, including helpful suggestions.\n\n          context.reportError(\n            new GraphQLError(\n              `Cannot query field \"${fieldName}\" on type \"${type.name}\".` +\n                suggestion,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n  };\n}\n/**\n * Go through all of the implementations of type, as well as the interfaces that\n * they implement. If any of those types include the provided field, suggest them,\n * sorted by how often the type is referenced.\n */\n\nfunction getSuggestedTypeNames(schema, type, fieldName) {\n  if (!isAbstractType(type)) {\n    // Must be an Object type, which does not have possible fields.\n    return [];\n  }\n\n  const suggestedTypes = new Set();\n  const usageCount = Object.create(null);\n\n  for (const possibleType of schema.getPossibleTypes(type)) {\n    if (!possibleType.getFields()[fieldName]) {\n      continue;\n    } // This object type defines this field.\n\n    suggestedTypes.add(possibleType);\n    usageCount[possibleType.name] = 1;\n\n    for (const possibleInterface of possibleType.getInterfaces()) {\n      var _usageCount$possibleI;\n\n      if (!possibleInterface.getFields()[fieldName]) {\n        continue;\n      } // This interface type defines this field.\n\n      suggestedTypes.add(possibleInterface);\n      usageCount[possibleInterface.name] =\n        ((_usageCount$possibleI = usageCount[possibleInterface.name]) !==\n          null && _usageCount$possibleI !== void 0\n          ? _usageCount$possibleI\n          : 0) + 1;\n    }\n  }\n\n  return [...suggestedTypes]\n    .sort((typeA, typeB) => {\n      // Suggest both interface and object types based on how common they are.\n      const usageCountDiff = usageCount[typeB.name] - usageCount[typeA.name];\n\n      if (usageCountDiff !== 0) {\n        return usageCountDiff;\n      } // Suggest super types first followed by subtypes\n\n      if (isInterfaceType(typeA) && schema.isSubType(typeA, typeB)) {\n        return -1;\n      }\n\n      if (isInterfaceType(typeB) && schema.isSubType(typeB, typeA)) {\n        return 1;\n      }\n\n      return naturalCompare(typeA.name, typeB.name);\n    })\n    .map((x) => x.name);\n}\n/**\n * For the field name provided, determine if there are any similar field names\n * that may be the result of a typo.\n */\n\nfunction getSuggestedFieldNames(type, fieldName) {\n  if (isObjectType(type) || isInterfaceType(type)) {\n    const possibleFieldNames = Object.keys(type.getFields());\n    return suggestionList(fieldName, possibleFieldNames);\n  } // Otherwise, must be a Union type, which does not define fields.\n\n  return [];\n}\n"],"names":[],"mappings":";;;;;AAkBO,SAAS,wBAAwB,SAAS;AAC/C,SAAO;AAAA,IACL,MAAM,MAAM;AACV,YAAM,OAAO,QAAQ,cAAa;AAElC,UAAI,MAAM;AACR,cAAM,WAAW,QAAQ,YAAW;AAEpC,YAAI,CAAC,UAAU;AAEb,gBAAM,SAAS,QAAQ,UAAS;AAChC,gBAAM,YAAY,KAAK,KAAK;AAE5B,cAAI,aAAa;AAAA,YACf;AAAA,YACA,sBAAsB,QAAQ,MAAM,SAAS;AAAA,UACzD;AAEU,cAAI,eAAe,IAAI;AACrB,yBAAa,WAAW,uBAAuB,MAAM,SAAS,CAAC;AAAA,UACjE;AAEA,kBAAQ;AAAA,YACN,IAAI;AAAA,cACF,uBAAuB,SAAS,cAAc,KAAK,IAAI,OACrD;AAAA,cACF;AAAA,gBACE,OAAO;AAAA,cACvB;AAAA,YACA;AAAA,UACA;AAAA,QACQ;AAAA,MACF;AAAA,IACF;AAAA,EACJ;AACA;AAOA,SAAS,sBAAsB,QAAQ,MAAM,WAAW;AACtD,MAAI,CAAC,eAAe,IAAI,GAAG;AAEzB,WAAO,CAAA;AAAA,EACT;AAEA,QAAM,iBAAiB,oBAAI,IAAG;AAC9B,QAAM,aAAa,uBAAO,OAAO,IAAI;AAErC,aAAW,gBAAgB,OAAO,iBAAiB,IAAI,GAAG;AACxD,QAAI,CAAC,aAAa,UAAS,EAAG,SAAS,GAAG;AACxC;AAAA,IACF;AAEA,mBAAe,IAAI,YAAY;AAC/B,eAAW,aAAa,IAAI,IAAI;AAEhC,eAAW,qBAAqB,aAAa,iBAAiB;AAC5D,UAAI;AAEJ,UAAI,CAAC,kBAAkB,UAAS,EAAG,SAAS,GAAG;AAC7C;AAAA,MACF;AAEA,qBAAe,IAAI,iBAAiB;AACpC,iBAAW,kBAAkB,IAAI,MAC7B,wBAAwB,WAAW,kBAAkB,IAAI,OACzD,QAAQ,0BAA0B,SAChC,wBACA,KAAK;AAAA,IACb;AAAA,EACF;AAEA,SAAO,CAAC,GAAG,cAAc,EACtB,KAAK,CAAC,OAAO,UAAU;AAEtB,UAAM,iBAAiB,WAAW,MAAM,IAAI,IAAI,WAAW,MAAM,IAAI;AAErE,QAAI,mBAAmB,GAAG;AACxB,aAAO;AAAA,IACT;AAEA,QAAI,gBAAgB,KAAK,KAAK,OAAO,UAAU,OAAO,KAAK,GAAG;AAC5D,aAAO;AAAA,IACT;AAEA,QAAI,gBAAgB,KAAK,KAAK,OAAO,UAAU,OAAO,KAAK,GAAG;AAC5D,aAAO;AAAA,IACT;AAEA,WAAO,eAAe,MAAM,MAAM,MAAM,IAAI;AAAA,EAC9C,CAAC,EACA,IAAI,CAAC,MAAM,EAAE,IAAI;AACtB;AAMA,SAAS,uBAAuB,MAAM,WAAW;AAC/C,MAAI,aAAa,IAAI,KAAK,gBAAgB,IAAI,GAAG;AAC/C,UAAM,qBAAqB,OAAO,KAAK,KAAK,UAAS,CAAE;AACvD,WAAO,eAAe,WAAW,kBAAkB;AAAA,EACrD;AAEA,SAAO,CAAA;AACT;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,43 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { print } from "../../language/printer.js";
+import { isCompositeType } from "../../type/definition.js";
+import { typeFromAST } from "../../utilities/typeFromAST.js";
+function FragmentsOnCompositeTypesRule(context) {
+  return {
+    InlineFragment(node) {
+      const typeCondition = node.typeCondition;
+      if (typeCondition) {
+        const type = typeFromAST(context.getSchema(), typeCondition);
+        if (type && !isCompositeType(type)) {
+          const typeStr = print(typeCondition);
+          context.reportError(
+            new GraphQLError(
+              `Fragment cannot condition on non composite type "${typeStr}".`,
+              {
+                nodes: typeCondition
+              }
+            )
+          );
+        }
+      }
+    },
+    FragmentDefinition(node) {
+      const type = typeFromAST(context.getSchema(), node.typeCondition);
+      if (type && !isCompositeType(type)) {
+        const typeStr = print(node.typeCondition);
+        context.reportError(
+          new GraphQLError(
+            `Fragment "${node.name.value}" cannot condition on non composite type "${typeStr}".`,
+            {
+              nodes: node.typeCondition
+            }
+          )
+        );
+      }
+    }
+  };
+}
+export {
+  FragmentsOnCompositeTypesRule
+};
+//# sourceMappingURL=FragmentsOnCompositeTypesRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FragmentsOnCompositeTypesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/FragmentsOnCompositeTypesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { print } from '../../language/printer.mjs';\nimport { isCompositeType } from '../../type/definition.mjs';\nimport { typeFromAST } from '../../utilities/typeFromAST.mjs';\n\n/**\n * Fragments on composite type\n *\n * Fragments use a type condition to determine if they apply, since fragments\n * can only be spread into a composite type (object, interface, or union), the\n * type condition must also be a composite type.\n *\n * See https://spec.graphql.org/draft/#sec-Fragments-On-Composite-Types\n */\nexport function FragmentsOnCompositeTypesRule(context) {\n  return {\n    InlineFragment(node) {\n      const typeCondition = node.typeCondition;\n\n      if (typeCondition) {\n        const type = typeFromAST(context.getSchema(), typeCondition);\n\n        if (type && !isCompositeType(type)) {\n          const typeStr = print(typeCondition);\n          context.reportError(\n            new GraphQLError(\n              `Fragment cannot condition on non composite type \"${typeStr}\".`,\n              {\n                nodes: typeCondition,\n              },\n            ),\n          );\n        }\n      }\n    },\n\n    FragmentDefinition(node) {\n      const type = typeFromAST(context.getSchema(), node.typeCondition);\n\n      if (type && !isCompositeType(type)) {\n        const typeStr = print(node.typeCondition);\n        context.reportError(\n          new GraphQLError(\n            `Fragment \"${node.name.value}\" cannot condition on non composite type \"${typeStr}\".`,\n            {\n              nodes: node.typeCondition,\n            },\n          ),\n        );\n      }\n    },\n  };\n}\n"],"names":[],"mappings":";;;;AAcO,SAAS,8BAA8B,SAAS;AACrD,SAAO;AAAA,IACL,eAAe,MAAM;AACnB,YAAM,gBAAgB,KAAK;AAE3B,UAAI,eAAe;AACjB,cAAM,OAAO,YAAY,QAAQ,UAAS,GAAI,aAAa;AAE3D,YAAI,QAAQ,CAAC,gBAAgB,IAAI,GAAG;AAClC,gBAAM,UAAU,MAAM,aAAa;AACnC,kBAAQ;AAAA,YACN,IAAI;AAAA,cACF,oDAAoD,OAAO;AAAA,cAC3D;AAAA,gBACE,OAAO;AAAA,cACvB;AAAA,YACA;AAAA,UACA;AAAA,QACQ;AAAA,MACF;AAAA,IACF;AAAA,IAEA,mBAAmB,MAAM;AACvB,YAAM,OAAO,YAAY,QAAQ,UAAS,GAAI,KAAK,aAAa;AAEhE,UAAI,QAAQ,CAAC,gBAAgB,IAAI,GAAG;AAClC,cAAM,UAAU,MAAM,KAAK,aAAa;AACxC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,aAAa,KAAK,KAAK,KAAK,6CAA6C,OAAO;AAAA,YAChF;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/KnownArgumentNamesRule.js

@@ -0,0 +1,73 @@
+import { didYouMean } from "../../jsutils/didYouMean.js";
+import { suggestionList } from "../../jsutils/suggestionList.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { specifiedDirectives } from "../../type/directives.js";
+function KnownArgumentNamesRule(context) {
+  return {
+    // eslint-disable-next-line new-cap
+    ...KnownArgumentNamesOnDirectivesRule(context),
+    Argument(argNode) {
+      const argDef = context.getArgument();
+      const fieldDef = context.getFieldDef();
+      const parentType = context.getParentType();
+      if (!argDef && fieldDef && parentType) {
+        const argName = argNode.name.value;
+        const knownArgsNames = fieldDef.args.map((arg) => arg.name);
+        const suggestions = suggestionList(argName, knownArgsNames);
+        context.reportError(
+          new GraphQLError(
+            `Unknown argument "${argName}" on field "${parentType.name}.${fieldDef.name}".` + didYouMean(suggestions),
+            {
+              nodes: argNode
+            }
+          )
+        );
+      }
+    }
+  };
+}
+function KnownArgumentNamesOnDirectivesRule(context) {
+  const directiveArgs = /* @__PURE__ */ Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
+  for (const directive of definedDirectives) {
+    directiveArgs[directive.name] = directive.args.map((arg) => arg.name);
+  }
+  const astDefinitions = context.getDocument().definitions;
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      var _def$arguments;
+      const argsNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : [];
+      directiveArgs[def.name.value] = argsNodes.map((arg) => arg.name.value);
+    }
+  }
+  return {
+    Directive(directiveNode) {
+      const directiveName = directiveNode.name.value;
+      const knownArgs = directiveArgs[directiveName];
+      if (directiveNode.arguments && knownArgs) {
+        for (const argNode of directiveNode.arguments) {
+          const argName = argNode.name.value;
+          if (!knownArgs.includes(argName)) {
+            const suggestions = suggestionList(argName, knownArgs);
+            context.reportError(
+              new GraphQLError(
+                `Unknown argument "${argName}" on directive "@${directiveName}".` + didYouMean(suggestions),
+                {
+                  nodes: argNode
+                }
+              )
+            );
+          }
+        }
+      }
+      return false;
+    }
+  };
+}
+export {
+  KnownArgumentNamesOnDirectivesRule,
+  KnownArgumentNamesRule
+};
+//# sourceMappingURL=KnownArgumentNamesRule.js.map