@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

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

@@ -0,0 +1,113 @@
+import { didYouMean } from "../../jsutils/didYouMean.js";
+import { inspect } from "../../jsutils/inspect.js";
+import { invariant } from "../../jsutils/invariant.js";
+import { suggestionList } from "../../jsutils/suggestionList.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { isTypeDefinitionNode } from "../../language/predicates.js";
+import { isScalarType, isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType } from "../../type/definition.js";
+function PossibleTypeExtensionsRule(context) {
+  const schema = context.getSchema();
+  const definedTypes = /* @__PURE__ */ Object.create(null);
+  for (const def of context.getDocument().definitions) {
+    if (isTypeDefinitionNode(def)) {
+      definedTypes[def.name.value] = def;
+    }
+  }
+  return {
+    ScalarTypeExtension: checkExtension,
+    ObjectTypeExtension: checkExtension,
+    InterfaceTypeExtension: checkExtension,
+    UnionTypeExtension: checkExtension,
+    EnumTypeExtension: checkExtension,
+    InputObjectTypeExtension: checkExtension
+  };
+  function checkExtension(node) {
+    const typeName = node.name.value;
+    const defNode = definedTypes[typeName];
+    const existingType = schema === null || schema === void 0 ? void 0 : schema.getType(typeName);
+    let expectedKind;
+    if (defNode) {
+      expectedKind = defKindToExtKind[defNode.kind];
+    } else if (existingType) {
+      expectedKind = typeToExtKind(existingType);
+    }
+    if (expectedKind) {
+      if (expectedKind !== node.kind) {
+        const kindStr = extensionKindToTypeName(node.kind);
+        context.reportError(
+          new GraphQLError(`Cannot extend non-${kindStr} type "${typeName}".`, {
+            nodes: defNode ? [defNode, node] : node
+          })
+        );
+      }
+    } else {
+      const allTypeNames = Object.keys({
+        ...definedTypes,
+        ...schema === null || schema === void 0 ? void 0 : schema.getTypeMap()
+      });
+      const suggestedTypes = suggestionList(typeName, allTypeNames);
+      context.reportError(
+        new GraphQLError(
+          `Cannot extend type "${typeName}" because it is not defined.` + didYouMean(suggestedTypes),
+          {
+            nodes: node.name
+          }
+        )
+      );
+    }
+  }
+}
+const defKindToExtKind = {
+  [Kind.SCALAR_TYPE_DEFINITION]: Kind.SCALAR_TYPE_EXTENSION,
+  [Kind.OBJECT_TYPE_DEFINITION]: Kind.OBJECT_TYPE_EXTENSION,
+  [Kind.INTERFACE_TYPE_DEFINITION]: Kind.INTERFACE_TYPE_EXTENSION,
+  [Kind.UNION_TYPE_DEFINITION]: Kind.UNION_TYPE_EXTENSION,
+  [Kind.ENUM_TYPE_DEFINITION]: Kind.ENUM_TYPE_EXTENSION,
+  [Kind.INPUT_OBJECT_TYPE_DEFINITION]: Kind.INPUT_OBJECT_TYPE_EXTENSION
+};
+function typeToExtKind(type) {
+  if (isScalarType(type)) {
+    return Kind.SCALAR_TYPE_EXTENSION;
+  }
+  if (isObjectType(type)) {
+    return Kind.OBJECT_TYPE_EXTENSION;
+  }
+  if (isInterfaceType(type)) {
+    return Kind.INTERFACE_TYPE_EXTENSION;
+  }
+  if (isUnionType(type)) {
+    return Kind.UNION_TYPE_EXTENSION;
+  }
+  if (isEnumType(type)) {
+    return Kind.ENUM_TYPE_EXTENSION;
+  }
+  if (isInputObjectType(type)) {
+    return Kind.INPUT_OBJECT_TYPE_EXTENSION;
+  }
+  invariant(false, "Unexpected type: " + inspect(type));
+}
+function extensionKindToTypeName(kind) {
+  switch (kind) {
+    case Kind.SCALAR_TYPE_EXTENSION:
+      return "scalar";
+    case Kind.OBJECT_TYPE_EXTENSION:
+      return "object";
+    case Kind.INTERFACE_TYPE_EXTENSION:
+      return "interface";
+    case Kind.UNION_TYPE_EXTENSION:
+      return "union";
+    case Kind.ENUM_TYPE_EXTENSION:
+      return "enum";
+    case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+      return "input object";
+    // Not reachable. All possible types have been considered
+    /* c8 ignore next */
+    default:
+      invariant(false, "Unexpected kind: " + inspect(kind));
+  }
+}
+export {
+  PossibleTypeExtensionsRule
+};
+//# sourceMappingURL=PossibleTypeExtensionsRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PossibleTypeExtensionsRule.js","sources":["../../../../../node_modules/graphql/validation/rules/PossibleTypeExtensionsRule.mjs"],"sourcesContent":["import { didYouMean } from '../../jsutils/didYouMean.mjs';\nimport { inspect } from '../../jsutils/inspect.mjs';\nimport { invariant } from '../../jsutils/invariant.mjs';\nimport { suggestionList } from '../../jsutils/suggestionList.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { isTypeDefinitionNode } from '../../language/predicates.mjs';\nimport {\n  isEnumType,\n  isInputObjectType,\n  isInterfaceType,\n  isObjectType,\n  isScalarType,\n  isUnionType,\n} from '../../type/definition.mjs';\n\n/**\n * Possible type extension\n *\n * A type extension is only valid if the type is defined and has the same kind.\n */\nexport function PossibleTypeExtensionsRule(context) {\n  const schema = context.getSchema();\n  const definedTypes = Object.create(null);\n\n  for (const def of context.getDocument().definitions) {\n    if (isTypeDefinitionNode(def)) {\n      definedTypes[def.name.value] = def;\n    }\n  }\n\n  return {\n    ScalarTypeExtension: checkExtension,\n    ObjectTypeExtension: checkExtension,\n    InterfaceTypeExtension: checkExtension,\n    UnionTypeExtension: checkExtension,\n    EnumTypeExtension: checkExtension,\n    InputObjectTypeExtension: checkExtension,\n  };\n\n  function checkExtension(node) {\n    const typeName = node.name.value;\n    const defNode = definedTypes[typeName];\n    const existingType =\n      schema === null || schema === void 0 ? void 0 : schema.getType(typeName);\n    let expectedKind;\n\n    if (defNode) {\n      expectedKind = defKindToExtKind[defNode.kind];\n    } else if (existingType) {\n      expectedKind = typeToExtKind(existingType);\n    }\n\n    if (expectedKind) {\n      if (expectedKind !== node.kind) {\n        const kindStr = extensionKindToTypeName(node.kind);\n        context.reportError(\n          new GraphQLError(`Cannot extend non-${kindStr} type \"${typeName}\".`, {\n            nodes: defNode ? [defNode, node] : node,\n          }),\n        );\n      }\n    } else {\n      const allTypeNames = Object.keys({\n        ...definedTypes,\n        ...(schema === null || schema === void 0\n          ? void 0\n          : schema.getTypeMap()),\n      });\n      const suggestedTypes = suggestionList(typeName, allTypeNames);\n      context.reportError(\n        new GraphQLError(\n          `Cannot extend type \"${typeName}\" because it is not defined.` +\n            didYouMean(suggestedTypes),\n          {\n            nodes: node.name,\n          },\n        ),\n      );\n    }\n  }\n}\nconst defKindToExtKind = {\n  [Kind.SCALAR_TYPE_DEFINITION]: Kind.SCALAR_TYPE_EXTENSION,\n  [Kind.OBJECT_TYPE_DEFINITION]: Kind.OBJECT_TYPE_EXTENSION,\n  [Kind.INTERFACE_TYPE_DEFINITION]: Kind.INTERFACE_TYPE_EXTENSION,\n  [Kind.UNION_TYPE_DEFINITION]: Kind.UNION_TYPE_EXTENSION,\n  [Kind.ENUM_TYPE_DEFINITION]: Kind.ENUM_TYPE_EXTENSION,\n  [Kind.INPUT_OBJECT_TYPE_DEFINITION]: Kind.INPUT_OBJECT_TYPE_EXTENSION,\n};\n\nfunction typeToExtKind(type) {\n  if (isScalarType(type)) {\n    return Kind.SCALAR_TYPE_EXTENSION;\n  }\n\n  if (isObjectType(type)) {\n    return Kind.OBJECT_TYPE_EXTENSION;\n  }\n\n  if (isInterfaceType(type)) {\n    return Kind.INTERFACE_TYPE_EXTENSION;\n  }\n\n  if (isUnionType(type)) {\n    return Kind.UNION_TYPE_EXTENSION;\n  }\n\n  if (isEnumType(type)) {\n    return Kind.ENUM_TYPE_EXTENSION;\n  }\n\n  if (isInputObjectType(type)) {\n    return Kind.INPUT_OBJECT_TYPE_EXTENSION;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable. All possible types have been considered\n\n  false || invariant(false, 'Unexpected type: ' + inspect(type));\n}\n\nfunction extensionKindToTypeName(kind) {\n  switch (kind) {\n    case Kind.SCALAR_TYPE_EXTENSION:\n      return 'scalar';\n\n    case Kind.OBJECT_TYPE_EXTENSION:\n      return 'object';\n\n    case Kind.INTERFACE_TYPE_EXTENSION:\n      return 'interface';\n\n    case Kind.UNION_TYPE_EXTENSION:\n      return 'union';\n\n    case Kind.ENUM_TYPE_EXTENSION:\n      return 'enum';\n\n    case Kind.INPUT_OBJECT_TYPE_EXTENSION:\n      return 'input object';\n    // Not reachable. All possible types have been considered\n\n    /* c8 ignore next */\n\n    default:\n      false || invariant(false, 'Unexpected kind: ' + inspect(kind));\n  }\n}\n"],"names":[],"mappings":";;;;;;;;AAqBO,SAAS,2BAA2B,SAAS;AAClD,QAAM,SAAS,QAAQ,UAAS;AAChC,QAAM,eAAe,uBAAO,OAAO,IAAI;AAEvC,aAAW,OAAO,QAAQ,YAAW,EAAG,aAAa;AACnD,QAAI,qBAAqB,GAAG,GAAG;AAC7B,mBAAa,IAAI,KAAK,KAAK,IAAI;AAAA,IACjC;AAAA,EACF;AAEA,SAAO;AAAA,IACL,qBAAqB;AAAA,IACrB,qBAAqB;AAAA,IACrB,wBAAwB;AAAA,IACxB,oBAAoB;AAAA,IACpB,mBAAmB;AAAA,IACnB,0BAA0B;AAAA,EAC9B;AAEE,WAAS,eAAe,MAAM;AAC5B,UAAM,WAAW,KAAK,KAAK;AAC3B,UAAM,UAAU,aAAa,QAAQ;AACrC,UAAM,eACJ,WAAW,QAAQ,WAAW,SAAS,SAAS,OAAO,QAAQ,QAAQ;AACzE,QAAI;AAEJ,QAAI,SAAS;AACX,qBAAe,iBAAiB,QAAQ,IAAI;AAAA,IAC9C,WAAW,cAAc;AACvB,qBAAe,cAAc,YAAY;AAAA,IAC3C;AAEA,QAAI,cAAc;AAChB,UAAI,iBAAiB,KAAK,MAAM;AAC9B,cAAM,UAAU,wBAAwB,KAAK,IAAI;AACjD,gBAAQ;AAAA,UACN,IAAI,aAAa,qBAAqB,OAAO,UAAU,QAAQ,MAAM;AAAA,YACnE,OAAO,UAAU,CAAC,SAAS,IAAI,IAAI;AAAA,UAC/C,CAAW;AAAA,QACX;AAAA,MACM;AAAA,IACF,OAAO;AACL,YAAM,eAAe,OAAO,KAAK;AAAA,QAC/B,GAAG;AAAA,QACH,GAAI,WAAW,QAAQ,WAAW,SAC9B,SACA,OAAO,WAAU;AAAA,MAC7B,CAAO;AACD,YAAM,iBAAiB,eAAe,UAAU,YAAY;AAC5D,cAAQ;AAAA,QACN,IAAI;AAAA,UACF,uBAAuB,QAAQ,iCAC7B,WAAW,cAAc;AAAA,UAC3B;AAAA,YACE,OAAO,KAAK;AAAA,UACxB;AAAA,QACA;AAAA,MACA;AAAA,IACI;AAAA,EACF;AACF;AACA,MAAM,mBAAmB;AAAA,EACvB,CAAC,KAAK,sBAAsB,GAAG,KAAK;AAAA,EACpC,CAAC,KAAK,sBAAsB,GAAG,KAAK;AAAA,EACpC,CAAC,KAAK,yBAAyB,GAAG,KAAK;AAAA,EACvC,CAAC,KAAK,qBAAqB,GAAG,KAAK;AAAA,EACnC,CAAC,KAAK,oBAAoB,GAAG,KAAK;AAAA,EAClC,CAAC,KAAK,4BAA4B,GAAG,KAAK;AAC5C;AAEA,SAAS,cAAc,MAAM;AAC3B,MAAI,aAAa,IAAI,GAAG;AACtB,WAAO,KAAK;AAAA,EACd;AAEA,MAAI,aAAa,IAAI,GAAG;AACtB,WAAO,KAAK;AAAA,EACd;AAEA,MAAI,gBAAgB,IAAI,GAAG;AACzB,WAAO,KAAK;AAAA,EACd;AAEA,MAAI,YAAY,IAAI,GAAG;AACrB,WAAO,KAAK;AAAA,EACd;AAEA,MAAI,WAAW,IAAI,GAAG;AACpB,WAAO,KAAK;AAAA,EACd;AAEA,MAAI,kBAAkB,IAAI,GAAG;AAC3B,WAAO,KAAK;AAAA,EACd;AAIS,YAAU,OAAO,sBAAsB,QAAQ,IAAI,CAAC;AAC/D;AAEA,SAAS,wBAAwB,MAAM;AACrC,UAAQ,MAAI;AAAA,IACV,KAAK,KAAK;AACR,aAAO;AAAA,IAET,KAAK,KAAK;AACR,aAAO;AAAA,IAET,KAAK,KAAK;AACR,aAAO;AAAA,IAET,KAAK,KAAK;AACR,aAAO;AAAA,IAET,KAAK,KAAK;AACR,aAAO;AAAA,IAET,KAAK,KAAK;AACR,aAAO;AAAA;AAAA;AAAA,IAKT;AACW,gBAAU,OAAO,sBAAsB,QAAQ,IAAI,CAAC;AAAA,EACnE;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,99 @@
+import { inspect } from "../../jsutils/inspect.js";
+import { keyMap } from "../../jsutils/keyMap.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { print } from "../../language/printer.js";
+import { isRequiredArgument, isType } from "../../type/definition.js";
+import { specifiedDirectives } from "../../type/directives.js";
+function ProvidedRequiredArgumentsRule(context) {
+  return {
+    // eslint-disable-next-line new-cap
+    ...ProvidedRequiredArgumentsOnDirectivesRule(context),
+    Field: {
+      // Validate on leave to allow for deeper errors to appear first.
+      leave(fieldNode) {
+        var _fieldNode$arguments;
+        const fieldDef = context.getFieldDef();
+        if (!fieldDef) {
+          return false;
+        }
+        const providedArgs = new Set(
+          // FIXME: https://github.com/graphql/graphql-js/issues/2203
+          /* c8 ignore next */
+          (_fieldNode$arguments = fieldNode.arguments) === null || _fieldNode$arguments === void 0 ? void 0 : _fieldNode$arguments.map((arg) => arg.name.value)
+        );
+        for (const argDef of fieldDef.args) {
+          if (!providedArgs.has(argDef.name) && isRequiredArgument(argDef)) {
+            const argTypeStr = inspect(argDef.type);
+            context.reportError(
+              new GraphQLError(
+                `Field "${fieldDef.name}" argument "${argDef.name}" of type "${argTypeStr}" is required, but it was not provided.`,
+                {
+                  nodes: fieldNode
+                }
+              )
+            );
+          }
+        }
+      }
+    }
+  };
+}
+function ProvidedRequiredArgumentsOnDirectivesRule(context) {
+  var _schema$getDirectives;
+  const requiredArgsMap = /* @__PURE__ */ Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = (_schema$getDirectives = schema === null || schema === void 0 ? void 0 : schema.getDirectives()) !== null && _schema$getDirectives !== void 0 ? _schema$getDirectives : specifiedDirectives;
+  for (const directive of definedDirectives) {
+    requiredArgsMap[directive.name] = keyMap(
+      directive.args.filter(isRequiredArgument),
+      (arg) => arg.name
+    );
+  }
+  const astDefinitions = context.getDocument().definitions;
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      var _def$arguments;
+      const argNodes = (_def$arguments = def.arguments) !== null && _def$arguments !== void 0 ? _def$arguments : [];
+      requiredArgsMap[def.name.value] = keyMap(
+        argNodes.filter(isRequiredArgumentNode),
+        (arg) => arg.name.value
+      );
+    }
+  }
+  return {
+    Directive: {
+      // Validate on leave to allow for deeper errors to appear first.
+      leave(directiveNode) {
+        const directiveName = directiveNode.name.value;
+        const requiredArgs = requiredArgsMap[directiveName];
+        if (requiredArgs) {
+          var _directiveNode$argume;
+          const argNodes = (_directiveNode$argume = directiveNode.arguments) !== null && _directiveNode$argume !== void 0 ? _directiveNode$argume : [];
+          const argNodeMap = new Set(argNodes.map((arg) => arg.name.value));
+          for (const [argName, argDef] of Object.entries(requiredArgs)) {
+            if (!argNodeMap.has(argName)) {
+              const argType = isType(argDef.type) ? inspect(argDef.type) : print(argDef.type);
+              context.reportError(
+                new GraphQLError(
+                  `Directive "@${directiveName}" argument "${argName}" of type "${argType}" is required, but it was not provided.`,
+                  {
+                    nodes: directiveNode
+                  }
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function isRequiredArgumentNode(arg) {
+  return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
+}
+export {
+  ProvidedRequiredArgumentsOnDirectivesRule,
+  ProvidedRequiredArgumentsRule
+};
+//# sourceMappingURL=ProvidedRequiredArgumentsRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProvidedRequiredArgumentsRule.js","sources":["../../../../../node_modules/graphql/validation/rules/ProvidedRequiredArgumentsRule.mjs"],"sourcesContent":["import { inspect } from '../../jsutils/inspect.mjs';\nimport { keyMap } from '../../jsutils/keyMap.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { print } from '../../language/printer.mjs';\nimport { isRequiredArgument, isType } from '../../type/definition.mjs';\nimport { specifiedDirectives } from '../../type/directives.mjs';\n\n/**\n * Provided required arguments\n *\n * A field or directive is only valid if all required (non-null without a\n * default value) field arguments have been provided.\n */\nexport function ProvidedRequiredArgumentsRule(context) {\n  return {\n    // eslint-disable-next-line new-cap\n    ...ProvidedRequiredArgumentsOnDirectivesRule(context),\n    Field: {\n      // Validate on leave to allow for deeper errors to appear first.\n      leave(fieldNode) {\n        var _fieldNode$arguments;\n\n        const fieldDef = context.getFieldDef();\n\n        if (!fieldDef) {\n          return false;\n        }\n\n        const providedArgs = new Set( // FIXME: https://github.com/graphql/graphql-js/issues/2203\n          /* c8 ignore next */\n          (_fieldNode$arguments = fieldNode.arguments) === null ||\n          _fieldNode$arguments === void 0\n            ? void 0\n            : _fieldNode$arguments.map((arg) => arg.name.value),\n        );\n\n        for (const argDef of fieldDef.args) {\n          if (!providedArgs.has(argDef.name) && isRequiredArgument(argDef)) {\n            const argTypeStr = inspect(argDef.type);\n            context.reportError(\n              new GraphQLError(\n                `Field \"${fieldDef.name}\" argument \"${argDef.name}\" of type \"${argTypeStr}\" is required, but it was not provided.`,\n                {\n                  nodes: fieldNode,\n                },\n              ),\n            );\n          }\n        }\n      },\n    },\n  };\n}\n/**\n * @internal\n */\n\nexport function ProvidedRequiredArgumentsOnDirectivesRule(context) {\n  var _schema$getDirectives;\n\n  const requiredArgsMap = Object.create(null);\n  const schema = context.getSchema();\n  const definedDirectives =\n    (_schema$getDirectives =\n      schema === null || schema === void 0\n        ? void 0\n        : schema.getDirectives()) !== null && _schema$getDirectives !== void 0\n      ? _schema$getDirectives\n      : specifiedDirectives;\n\n  for (const directive of definedDirectives) {\n    requiredArgsMap[directive.name] = keyMap(\n      directive.args.filter(isRequiredArgument),\n      (arg) => arg.name,\n    );\n  }\n\n  const astDefinitions = context.getDocument().definitions;\n\n  for (const def of astDefinitions) {\n    if (def.kind === Kind.DIRECTIVE_DEFINITION) {\n      var _def$arguments;\n\n      // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const argNodes =\n        (_def$arguments = def.arguments) !== null && _def$arguments !== void 0\n          ? _def$arguments\n          : [];\n      requiredArgsMap[def.name.value] = keyMap(\n        argNodes.filter(isRequiredArgumentNode),\n        (arg) => arg.name.value,\n      );\n    }\n  }\n\n  return {\n    Directive: {\n      // Validate on leave to allow for deeper errors to appear first.\n      leave(directiveNode) {\n        const directiveName = directiveNode.name.value;\n        const requiredArgs = requiredArgsMap[directiveName];\n\n        if (requiredArgs) {\n          var _directiveNode$argume;\n\n          // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n          /* c8 ignore next */\n          const argNodes =\n            (_directiveNode$argume = directiveNode.arguments) !== null &&\n            _directiveNode$argume !== void 0\n              ? _directiveNode$argume\n              : [];\n          const argNodeMap = new Set(argNodes.map((arg) => arg.name.value));\n\n          for (const [argName, argDef] of Object.entries(requiredArgs)) {\n            if (!argNodeMap.has(argName)) {\n              const argType = isType(argDef.type)\n                ? inspect(argDef.type)\n                : print(argDef.type);\n              context.reportError(\n                new GraphQLError(\n                  `Directive \"@${directiveName}\" argument \"${argName}\" of type \"${argType}\" is required, but it was not provided.`,\n                  {\n                    nodes: directiveNode,\n                  },\n                ),\n              );\n            }\n          }\n        }\n      },\n    },\n  };\n}\n\nfunction isRequiredArgumentNode(arg) {\n  return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;\n}\n"],"names":[],"mappings":";;;;;;;AAcO,SAAS,8BAA8B,SAAS;AACrD,SAAO;AAAA;AAAA,IAEL,GAAG,0CAA0C,OAAO;AAAA,IACpD,OAAO;AAAA;AAAA,MAEL,MAAM,WAAW;AACf,YAAI;AAEJ,cAAM,WAAW,QAAQ,YAAW;AAEpC,YAAI,CAAC,UAAU;AACb,iBAAO;AAAA,QACT;AAEA,cAAM,eAAe,IAAI;AAAA;AAAA;AAAA,WAEtB,uBAAuB,UAAU,eAAe,QACjD,yBAAyB,SACrB,SACA,qBAAqB,IAAI,CAAC,QAAQ,IAAI,KAAK,KAAK;AAAA,QAC9D;AAEQ,mBAAW,UAAU,SAAS,MAAM;AAClC,cAAI,CAAC,aAAa,IAAI,OAAO,IAAI,KAAK,mBAAmB,MAAM,GAAG;AAChE,kBAAM,aAAa,QAAQ,OAAO,IAAI;AACtC,oBAAQ;AAAA,cACN,IAAI;AAAA,gBACF,UAAU,SAAS,IAAI,eAAe,OAAO,IAAI,cAAc,UAAU;AAAA,gBACzE;AAAA,kBACE,OAAO;AAAA,gBACzB;AAAA,cACA;AAAA,YACA;AAAA,UACU;AAAA,QACF;AAAA,MACF;AAAA,IACN;AAAA,EACA;AACA;AAKO,SAAS,0CAA0C,SAAS;AACjE,MAAI;AAEJ,QAAM,kBAAkB,uBAAO,OAAO,IAAI;AAC1C,QAAM,SAAS,QAAQ,UAAS;AAChC,QAAM,qBACH,wBACC,WAAW,QAAQ,WAAW,SAC1B,SACA,OAAO,cAAa,OAAQ,QAAQ,0BAA0B,SAChE,wBACA;AAEN,aAAW,aAAa,mBAAmB;AACzC,oBAAgB,UAAU,IAAI,IAAI;AAAA,MAChC,UAAU,KAAK,OAAO,kBAAkB;AAAA,MACxC,CAAC,QAAQ,IAAI;AAAA,IACnB;AAAA,EACE;AAEA,QAAM,iBAAiB,QAAQ,YAAW,EAAG;AAE7C,aAAW,OAAO,gBAAgB;AAChC,QAAI,IAAI,SAAS,KAAK,sBAAsB;AAC1C,UAAI;AAKJ,YAAM,YACH,iBAAiB,IAAI,eAAe,QAAQ,mBAAmB,SAC5D,iBACA,CAAA;AACN,sBAAgB,IAAI,KAAK,KAAK,IAAI;AAAA,QAChC,SAAS,OAAO,sBAAsB;AAAA,QACtC,CAAC,QAAQ,IAAI,KAAK;AAAA,MAC1B;AAAA,IACI;AAAA,EACF;AAEA,SAAO;AAAA,IACL,WAAW;AAAA;AAAA,MAET,MAAM,eAAe;AACnB,cAAM,gBAAgB,cAAc,KAAK;AACzC,cAAM,eAAe,gBAAgB,aAAa;AAElD,YAAI,cAAc;AAChB,cAAI;AAKJ,gBAAM,YACH,wBAAwB,cAAc,eAAe,QACtD,0BAA0B,SACtB,wBACA,CAAA;AACN,gBAAM,aAAa,IAAI,IAAI,SAAS,IAAI,CAAC,QAAQ,IAAI,KAAK,KAAK,CAAC;AAEhE,qBAAW,CAAC,SAAS,MAAM,KAAK,OAAO,QAAQ,YAAY,GAAG;AAC5D,gBAAI,CAAC,WAAW,IAAI,OAAO,GAAG;AAC5B,oBAAM,UAAU,OAAO,OAAO,IAAI,IAC9B,QAAQ,OAAO,IAAI,IACnB,MAAM,OAAO,IAAI;AACrB,sBAAQ;AAAA,gBACN,IAAI;AAAA,kBACF,eAAe,aAAa,eAAe,OAAO,cAAc,OAAO;AAAA,kBACvE;AAAA,oBACE,OAAO;AAAA,kBAC3B;AAAA,gBACA;AAAA,cACA;AAAA,YACY;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACN;AAAA,EACA;AACA;AAEA,SAAS,uBAAuB,KAAK;AACnC,SAAO,IAAI,KAAK,SAAS,KAAK,iBAAiB,IAAI,gBAAgB;AACrE;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,53 @@
+import { inspect } from "../../jsutils/inspect.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { isLeafType, getNamedType } from "../../type/definition.js";
+function ScalarLeafsRule(context) {
+  return {
+    Field(node) {
+      const type = context.getType();
+      const selectionSet = node.selectionSet;
+      if (type) {
+        if (isLeafType(getNamedType(type))) {
+          if (selectionSet) {
+            const fieldName = node.name.value;
+            const typeStr = inspect(type);
+            context.reportError(
+              new GraphQLError(
+                `Field "${fieldName}" must not have a selection since type "${typeStr}" has no subfields.`,
+                {
+                  nodes: selectionSet
+                }
+              )
+            );
+          }
+        } else if (!selectionSet) {
+          const fieldName = node.name.value;
+          const typeStr = inspect(type);
+          context.reportError(
+            new GraphQLError(
+              `Field "${fieldName}" of type "${typeStr}" must have a selection of subfields. Did you mean "${fieldName} { ... }"?`,
+              {
+                nodes: node
+              }
+            )
+          );
+        } else if (selectionSet.selections.length === 0) {
+          const fieldName = node.name.value;
+          const typeStr = inspect(type);
+          context.reportError(
+            new GraphQLError(
+              `Field "${fieldName}" of type "${typeStr}" must have at least one field selected.`,
+              {
+                nodes: node
+              }
+            )
+          );
+        }
+      }
+    }
+  };
+}
+export {
+  ScalarLeafsRule
+};
+//# sourceMappingURL=ScalarLeafsRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarLeafsRule.js","sources":["../../../../../node_modules/graphql/validation/rules/ScalarLeafsRule.mjs"],"sourcesContent":["import { inspect } from '../../jsutils/inspect.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { getNamedType, isLeafType } from '../../type/definition.mjs';\n\n/**\n * Scalar leafs\n *\n * A GraphQL document is valid only if all leaf fields (fields without\n * sub selections) are of scalar or enum types.\n */\nexport function ScalarLeafsRule(context) {\n  return {\n    Field(node) {\n      const type = context.getType();\n      const selectionSet = node.selectionSet;\n\n      if (type) {\n        if (isLeafType(getNamedType(type))) {\n          if (selectionSet) {\n            const fieldName = node.name.value;\n            const typeStr = inspect(type);\n            context.reportError(\n              new GraphQLError(\n                `Field \"${fieldName}\" must not have a selection since type \"${typeStr}\" has no subfields.`,\n                {\n                  nodes: selectionSet,\n                },\n              ),\n            );\n          }\n        } else if (!selectionSet) {\n          const fieldName = node.name.value;\n          const typeStr = inspect(type);\n          context.reportError(\n            new GraphQLError(\n              `Field \"${fieldName}\" of type \"${typeStr}\" must have a selection of subfields. Did you mean \"${fieldName} { ... }\"?`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        } else if (selectionSet.selections.length === 0) {\n          const fieldName = node.name.value;\n          const typeStr = inspect(type);\n          context.reportError(\n            new GraphQLError(\n              `Field \"${fieldName}\" of type \"${typeStr}\" must have at least one field selected.`,\n              {\n                nodes: node,\n              },\n            ),\n          );\n        }\n      }\n    },\n  };\n}\n"],"names":[],"mappings":";;;AAUO,SAAS,gBAAgB,SAAS;AACvC,SAAO;AAAA,IACL,MAAM,MAAM;AACV,YAAM,OAAO,QAAQ,QAAO;AAC5B,YAAM,eAAe,KAAK;AAE1B,UAAI,MAAM;AACR,YAAI,WAAW,aAAa,IAAI,CAAC,GAAG;AAClC,cAAI,cAAc;AAChB,kBAAM,YAAY,KAAK,KAAK;AAC5B,kBAAM,UAAU,QAAQ,IAAI;AAC5B,oBAAQ;AAAA,cACN,IAAI;AAAA,gBACF,UAAU,SAAS,2CAA2C,OAAO;AAAA,gBACrE;AAAA,kBACE,OAAO;AAAA,gBACzB;AAAA,cACA;AAAA,YACA;AAAA,UACU;AAAA,QACF,WAAW,CAAC,cAAc;AACxB,gBAAM,YAAY,KAAK,KAAK;AAC5B,gBAAM,UAAU,QAAQ,IAAI;AAC5B,kBAAQ;AAAA,YACN,IAAI;AAAA,cACF,UAAU,SAAS,cAAc,OAAO,uDAAuD,SAAS;AAAA,cACxG;AAAA,gBACE,OAAO;AAAA,cACvB;AAAA,YACA;AAAA,UACA;AAAA,QACQ,WAAW,aAAa,WAAW,WAAW,GAAG;AAC/C,gBAAM,YAAY,KAAK,KAAK;AAC5B,gBAAM,UAAU,QAAQ,IAAI;AAC5B,kBAAQ;AAAA,YACN,IAAI;AAAA,cACF,UAAU,SAAS,cAAc,OAAO;AAAA,cACxC;AAAA,gBACE,OAAO;AAAA,cACvB;AAAA,YACA;AAAA,UACA;AAAA,QACQ;AAAA,MACF;AAAA,IACF;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,62 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { collectFields } from "../../execution/collectFields.js";
+function SingleFieldSubscriptionsRule(context) {
+  return {
+    OperationDefinition(node) {
+      if (node.operation === "subscription") {
+        const schema = context.getSchema();
+        const subscriptionType = schema.getSubscriptionType();
+        if (subscriptionType) {
+          const operationName = node.name ? node.name.value : null;
+          const variableValues = /* @__PURE__ */ Object.create(null);
+          const document = context.getDocument();
+          const fragments = /* @__PURE__ */ Object.create(null);
+          for (const definition of document.definitions) {
+            if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+              fragments[definition.name.value] = definition;
+            }
+          }
+          const fields = collectFields(
+            schema,
+            fragments,
+            variableValues,
+            subscriptionType,
+            node.selectionSet
+          );
+          if (fields.size > 1) {
+            const fieldSelectionLists = [...fields.values()];
+            const extraFieldSelectionLists = fieldSelectionLists.slice(1);
+            const extraFieldSelections = extraFieldSelectionLists.flat();
+            context.reportError(
+              new GraphQLError(
+                operationName != null ? `Subscription "${operationName}" must select only one top level field.` : "Anonymous Subscription must select only one top level field.",
+                {
+                  nodes: extraFieldSelections
+                }
+              )
+            );
+          }
+          for (const fieldNodes of fields.values()) {
+            const field = fieldNodes[0];
+            const fieldName = field.name.value;
+            if (fieldName.startsWith("__")) {
+              context.reportError(
+                new GraphQLError(
+                  operationName != null ? `Subscription "${operationName}" must not select an introspection top level field.` : "Anonymous Subscription must not select an introspection top level field.",
+                  {
+                    nodes: fieldNodes
+                  }
+                )
+              );
+            }
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  SingleFieldSubscriptionsRule
+};
+//# sourceMappingURL=SingleFieldSubscriptionsRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SingleFieldSubscriptionsRule.js","sources":["../../../../../node_modules/graphql/validation/rules/SingleFieldSubscriptionsRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport { collectFields } from '../../execution/collectFields.mjs';\n\n/**\n * Subscriptions must only include a non-introspection field.\n *\n * A GraphQL subscription is valid only if it contains a single root field and\n * that root field is not an introspection field.\n *\n * See https://spec.graphql.org/draft/#sec-Single-root-field\n */\nexport function SingleFieldSubscriptionsRule(context) {\n  return {\n    OperationDefinition(node) {\n      if (node.operation === 'subscription') {\n        const schema = context.getSchema();\n        const subscriptionType = schema.getSubscriptionType();\n\n        if (subscriptionType) {\n          const operationName = node.name ? node.name.value : null;\n          const variableValues = Object.create(null);\n          const document = context.getDocument();\n          const fragments = Object.create(null);\n\n          for (const definition of document.definitions) {\n            if (definition.kind === Kind.FRAGMENT_DEFINITION) {\n              fragments[definition.name.value] = definition;\n            }\n          }\n\n          const fields = collectFields(\n            schema,\n            fragments,\n            variableValues,\n            subscriptionType,\n            node.selectionSet,\n          );\n\n          if (fields.size > 1) {\n            const fieldSelectionLists = [...fields.values()];\n            const extraFieldSelectionLists = fieldSelectionLists.slice(1);\n            const extraFieldSelections = extraFieldSelectionLists.flat();\n            context.reportError(\n              new GraphQLError(\n                operationName != null\n                  ? `Subscription \"${operationName}\" must select only one top level field.`\n                  : 'Anonymous Subscription must select only one top level field.',\n                {\n                  nodes: extraFieldSelections,\n                },\n              ),\n            );\n          }\n\n          for (const fieldNodes of fields.values()) {\n            const field = fieldNodes[0];\n            const fieldName = field.name.value;\n\n            if (fieldName.startsWith('__')) {\n              context.reportError(\n                new GraphQLError(\n                  operationName != null\n                    ? `Subscription \"${operationName}\" must not select an introspection top level field.`\n                    : 'Anonymous Subscription must not select an introspection top level field.',\n                  {\n                    nodes: fieldNodes,\n                  },\n                ),\n              );\n            }\n          }\n        }\n      }\n    },\n  };\n}\n"],"names":[],"mappings":";;;AAYO,SAAS,6BAA6B,SAAS;AACpD,SAAO;AAAA,IACL,oBAAoB,MAAM;AACxB,UAAI,KAAK,cAAc,gBAAgB;AACrC,cAAM,SAAS,QAAQ,UAAS;AAChC,cAAM,mBAAmB,OAAO,oBAAmB;AAEnD,YAAI,kBAAkB;AACpB,gBAAM,gBAAgB,KAAK,OAAO,KAAK,KAAK,QAAQ;AACpD,gBAAM,iBAAiB,uBAAO,OAAO,IAAI;AACzC,gBAAM,WAAW,QAAQ,YAAW;AACpC,gBAAM,YAAY,uBAAO,OAAO,IAAI;AAEpC,qBAAW,cAAc,SAAS,aAAa;AAC7C,gBAAI,WAAW,SAAS,KAAK,qBAAqB;AAChD,wBAAU,WAAW,KAAK,KAAK,IAAI;AAAA,YACrC;AAAA,UACF;AAEA,gBAAM,SAAS;AAAA,YACb;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,KAAK;AAAA,UACjB;AAEU,cAAI,OAAO,OAAO,GAAG;AACnB,kBAAM,sBAAsB,CAAC,GAAG,OAAO,OAAM,CAAE;AAC/C,kBAAM,2BAA2B,oBAAoB,MAAM,CAAC;AAC5D,kBAAM,uBAAuB,yBAAyB,KAAI;AAC1D,oBAAQ;AAAA,cACN,IAAI;AAAA,gBACF,iBAAiB,OACb,iBAAiB,aAAa,4CAC9B;AAAA,gBACJ;AAAA,kBACE,OAAO;AAAA,gBACzB;AAAA,cACA;AAAA,YACA;AAAA,UACU;AAEA,qBAAW,cAAc,OAAO,UAAU;AACxC,kBAAM,QAAQ,WAAW,CAAC;AAC1B,kBAAM,YAAY,MAAM,KAAK;AAE7B,gBAAI,UAAU,WAAW,IAAI,GAAG;AAC9B,sBAAQ;AAAA,gBACN,IAAI;AAAA,kBACF,iBAAiB,OACb,iBAAiB,aAAa,wDAC9B;AAAA,kBACJ;AAAA,oBACE,OAAO;AAAA,kBAC3B;AAAA,gBACA;AAAA,cACA;AAAA,YACY;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,47 @@
+import { groupBy } from "../../jsutils/groupBy.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueArgumentDefinitionNamesRule(context) {
+  return {
+    DirectiveDefinition(directiveNode) {
+      var _directiveNode$argume;
+      const argumentNodes = (_directiveNode$argume = directiveNode.arguments) !== null && _directiveNode$argume !== void 0 ? _directiveNode$argume : [];
+      return checkArgUniqueness(`@${directiveNode.name.value}`, argumentNodes);
+    },
+    InterfaceTypeDefinition: checkArgUniquenessPerField,
+    InterfaceTypeExtension: checkArgUniquenessPerField,
+    ObjectTypeDefinition: checkArgUniquenessPerField,
+    ObjectTypeExtension: checkArgUniquenessPerField
+  };
+  function checkArgUniquenessPerField(typeNode) {
+    var _typeNode$fields;
+    const typeName = typeNode.name.value;
+    const fieldNodes = (_typeNode$fields = typeNode.fields) !== null && _typeNode$fields !== void 0 ? _typeNode$fields : [];
+    for (const fieldDef of fieldNodes) {
+      var _fieldDef$arguments;
+      const fieldName = fieldDef.name.value;
+      const argumentNodes = (_fieldDef$arguments = fieldDef.arguments) !== null && _fieldDef$arguments !== void 0 ? _fieldDef$arguments : [];
+      checkArgUniqueness(`${typeName}.${fieldName}`, argumentNodes);
+    }
+    return false;
+  }
+  function checkArgUniqueness(parentName, argumentNodes) {
+    const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);
+    for (const [argName, argNodes] of seenArgs) {
+      if (argNodes.length > 1) {
+        context.reportError(
+          new GraphQLError(
+            `Argument "${parentName}(${argName}:)" can only be defined once.`,
+            {
+              nodes: argNodes.map((node) => node.name)
+            }
+          )
+        );
+      }
+    }
+    return false;
+  }
+}
+export {
+  UniqueArgumentDefinitionNamesRule
+};
+//# sourceMappingURL=UniqueArgumentDefinitionNamesRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueArgumentDefinitionNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueArgumentDefinitionNamesRule.mjs"],"sourcesContent":["import { groupBy } from '../../jsutils/groupBy.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique argument definition names\n *\n * A GraphQL Object or Interface type is only valid if all its fields have uniquely named arguments.\n * A GraphQL Directive is only valid if all its arguments are uniquely named.\n */\nexport function UniqueArgumentDefinitionNamesRule(context) {\n  return {\n    DirectiveDefinition(directiveNode) {\n      var _directiveNode$argume;\n\n      // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n      const argumentNodes =\n        (_directiveNode$argume = directiveNode.arguments) !== null &&\n        _directiveNode$argume !== void 0\n          ? _directiveNode$argume\n          : [];\n      return checkArgUniqueness(`@${directiveNode.name.value}`, argumentNodes);\n    },\n\n    InterfaceTypeDefinition: checkArgUniquenessPerField,\n    InterfaceTypeExtension: checkArgUniquenessPerField,\n    ObjectTypeDefinition: checkArgUniquenessPerField,\n    ObjectTypeExtension: checkArgUniquenessPerField,\n  };\n\n  function checkArgUniquenessPerField(typeNode) {\n    var _typeNode$fields;\n\n    const typeName = typeNode.name.value; // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n\n    const fieldNodes =\n      (_typeNode$fields = typeNode.fields) !== null &&\n      _typeNode$fields !== void 0\n        ? _typeNode$fields\n        : [];\n\n    for (const fieldDef of fieldNodes) {\n      var _fieldDef$arguments;\n\n      const fieldName = fieldDef.name.value; // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n      /* c8 ignore next */\n\n      const argumentNodes =\n        (_fieldDef$arguments = fieldDef.arguments) !== null &&\n        _fieldDef$arguments !== void 0\n          ? _fieldDef$arguments\n          : [];\n      checkArgUniqueness(`${typeName}.${fieldName}`, argumentNodes);\n    }\n\n    return false;\n  }\n\n  function checkArgUniqueness(parentName, argumentNodes) {\n    const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);\n\n    for (const [argName, argNodes] of seenArgs) {\n      if (argNodes.length > 1) {\n        context.reportError(\n          new GraphQLError(\n            `Argument \"${parentName}(${argName}:)\" can only be defined once.`,\n            {\n              nodes: argNodes.map((node) => node.name),\n            },\n          ),\n        );\n      }\n    }\n\n    return false;\n  }\n}\n"],"names":[],"mappings":";;AASO,SAAS,kCAAkC,SAAS;AACzD,SAAO;AAAA,IACL,oBAAoB,eAAe;AACjC,UAAI;AAKJ,YAAM,iBACH,wBAAwB,cAAc,eAAe,QACtD,0BAA0B,SACtB,wBACA,CAAA;AACN,aAAO,mBAAmB,IAAI,cAAc,KAAK,KAAK,IAAI,aAAa;AAAA,IACzE;AAAA,IAEA,yBAAyB;AAAA,IACzB,wBAAwB;AAAA,IACxB,sBAAsB;AAAA,IACtB,qBAAqB;AAAA,EACzB;AAEE,WAAS,2BAA2B,UAAU;AAC5C,QAAI;AAEJ,UAAM,WAAW,SAAS,KAAK;AAI/B,UAAM,cACH,mBAAmB,SAAS,YAAY,QACzC,qBAAqB,SACjB,mBACA,CAAA;AAEN,eAAW,YAAY,YAAY;AACjC,UAAI;AAEJ,YAAM,YAAY,SAAS,KAAK;AAIhC,YAAM,iBACH,sBAAsB,SAAS,eAAe,QAC/C,wBAAwB,SACpB,sBACA,CAAA;AACN,yBAAmB,GAAG,QAAQ,IAAI,SAAS,IAAI,aAAa;AAAA,IAC9D;AAEA,WAAO;AAAA,EACT;AAEA,WAAS,mBAAmB,YAAY,eAAe;AACrD,UAAM,WAAW,QAAQ,eAAe,CAAC,QAAQ,IAAI,KAAK,KAAK;AAE/D,eAAW,CAAC,SAAS,QAAQ,KAAK,UAAU;AAC1C,UAAI,SAAS,SAAS,GAAG;AACvB,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,aAAa,UAAU,IAAI,OAAO;AAAA,YAClC;AAAA,cACE,OAAO,SAAS,IAAI,CAAC,SAAS,KAAK,IAAI;AAAA,YACrD;AAAA,UACA;AAAA,QACA;AAAA,MACM;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,29 @@
+import { groupBy } from "../../jsutils/groupBy.js";
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueArgumentNamesRule(context) {
+  return {
+    Field: checkArgUniqueness,
+    Directive: checkArgUniqueness
+  };
+  function checkArgUniqueness(parentNode) {
+    var _parentNode$arguments;
+    const argumentNodes = (_parentNode$arguments = parentNode.arguments) !== null && _parentNode$arguments !== void 0 ? _parentNode$arguments : [];
+    const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);
+    for (const [argName, argNodes] of seenArgs) {
+      if (argNodes.length > 1) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one argument named "${argName}".`,
+            {
+              nodes: argNodes.map((node) => node.name)
+            }
+          )
+        );
+      }
+    }
+  }
+}
+export {
+  UniqueArgumentNamesRule
+};
+//# sourceMappingURL=UniqueArgumentNamesRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueArgumentNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueArgumentNamesRule.mjs"],"sourcesContent":["import { groupBy } from '../../jsutils/groupBy.mjs';\nimport { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique argument names\n *\n * A GraphQL field or directive is only valid if all supplied arguments are\n * uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Argument-Names\n */\nexport function UniqueArgumentNamesRule(context) {\n  return {\n    Field: checkArgUniqueness,\n    Directive: checkArgUniqueness,\n  };\n\n  function checkArgUniqueness(parentNode) {\n    var _parentNode$arguments;\n\n    // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n    /* c8 ignore next */\n    const argumentNodes =\n      (_parentNode$arguments = parentNode.arguments) !== null &&\n      _parentNode$arguments !== void 0\n        ? _parentNode$arguments\n        : [];\n    const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);\n\n    for (const [argName, argNodes] of seenArgs) {\n      if (argNodes.length > 1) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one argument named \"${argName}\".`,\n            {\n              nodes: argNodes.map((node) => node.name),\n            },\n          ),\n        );\n      }\n    }\n  }\n}\n"],"names":[],"mappings":";;AAWO,SAAS,wBAAwB,SAAS;AAC/C,SAAO;AAAA,IACL,OAAO;AAAA,IACP,WAAW;AAAA,EACf;AAEE,WAAS,mBAAmB,YAAY;AACtC,QAAI;AAKJ,UAAM,iBACH,wBAAwB,WAAW,eAAe,QACnD,0BAA0B,SACtB,wBACA,CAAA;AACN,UAAM,WAAW,QAAQ,eAAe,CAAC,QAAQ,IAAI,KAAK,KAAK;AAE/D,eAAW,CAAC,SAAS,QAAQ,KAAK,UAAU;AAC1C,UAAI,SAAS,SAAS,GAAG;AACvB,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,yCAAyC,OAAO;AAAA,YAChD;AAAA,cACE,OAAO,SAAS,IAAI,CAAC,SAAS,KAAK,IAAI;AAAA,YACrD;AAAA,UACA;AAAA,QACA;AAAA,MACM;AAAA,IACF;AAAA,EACF;AACF;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,38 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+function UniqueDirectiveNamesRule(context) {
+  const knownDirectiveNames = /* @__PURE__ */ Object.create(null);
+  const schema = context.getSchema();
+  return {
+    DirectiveDefinition(node) {
+      const directiveName = node.name.value;
+      if (schema !== null && schema !== void 0 && schema.getDirective(directiveName)) {
+        context.reportError(
+          new GraphQLError(
+            `Directive "@${directiveName}" already exists in the schema. It cannot be redefined.`,
+            {
+              nodes: node.name
+            }
+          )
+        );
+        return;
+      }
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one directive named "@${directiveName}".`,
+            {
+              nodes: [knownDirectiveNames[directiveName], node.name]
+            }
+          )
+        );
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+      return false;
+    }
+  };
+}
+export {
+  UniqueDirectiveNamesRule
+};
+//# sourceMappingURL=UniqueDirectiveNamesRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueDirectiveNamesRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueDirectiveNamesRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\n\n/**\n * Unique directive names\n *\n * A GraphQL document is only valid if all defined directives have unique names.\n */\nexport function UniqueDirectiveNamesRule(context) {\n  const knownDirectiveNames = Object.create(null);\n  const schema = context.getSchema();\n  return {\n    DirectiveDefinition(node) {\n      const directiveName = node.name.value;\n\n      if (\n        schema !== null &&\n        schema !== void 0 &&\n        schema.getDirective(directiveName)\n      ) {\n        context.reportError(\n          new GraphQLError(\n            `Directive \"@${directiveName}\" already exists in the schema. It cannot be redefined.`,\n            {\n              nodes: node.name,\n            },\n          ),\n        );\n        return;\n      }\n\n      if (knownDirectiveNames[directiveName]) {\n        context.reportError(\n          new GraphQLError(\n            `There can be only one directive named \"@${directiveName}\".`,\n            {\n              nodes: [knownDirectiveNames[directiveName], node.name],\n            },\n          ),\n        );\n      } else {\n        knownDirectiveNames[directiveName] = node.name;\n      }\n\n      return false;\n    },\n  };\n}\n"],"names":[],"mappings":";AAOO,SAAS,yBAAyB,SAAS;AAChD,QAAM,sBAAsB,uBAAO,OAAO,IAAI;AAC9C,QAAM,SAAS,QAAQ,UAAS;AAChC,SAAO;AAAA,IACL,oBAAoB,MAAM;AACxB,YAAM,gBAAgB,KAAK,KAAK;AAEhC,UACE,WAAW,QACX,WAAW,UACX,OAAO,aAAa,aAAa,GACjC;AACA,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,eAAe,aAAa;AAAA,YAC5B;AAAA,cACE,OAAO,KAAK;AAAA,YAC1B;AAAA,UACA;AAAA,QACA;AACQ;AAAA,MACF;AAEA,UAAI,oBAAoB,aAAa,GAAG;AACtC,gBAAQ;AAAA,UACN,IAAI;AAAA,YACF,2CAA2C,aAAa;AAAA,YACxD;AAAA,cACE,OAAO,CAAC,oBAAoB,aAAa,GAAG,KAAK,IAAI;AAAA,YACnE;AAAA,UACA;AAAA,QACA;AAAA,MACM,OAAO;AACL,4BAAoB,aAAa,IAAI,KAAK;AAAA,MAC5C;AAEA,aAAO;AAAA,IACT;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,63 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { Kind } from "../../language/kinds.js";
+import { isTypeDefinitionNode, isTypeExtensionNode } from "../../language/predicates.js";
+import { specifiedDirectives } from "../../type/directives.js";
+function UniqueDirectivesPerLocationRule(context) {
+  const uniqueDirectiveMap = /* @__PURE__ */ Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema ? schema.getDirectives() : specifiedDirectives;
+  for (const directive of definedDirectives) {
+    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
+  }
+  const astDefinitions = context.getDocument().definitions;
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      uniqueDirectiveMap[def.name.value] = !def.repeatable;
+    }
+  }
+  const schemaDirectives = /* @__PURE__ */ Object.create(null);
+  const typeDirectivesMap = /* @__PURE__ */ Object.create(null);
+  return {
+    // Many different AST nodes may contain directives. Rather than listing
+    // them all, just listen for entering any node, and check to see if it
+    // defines any directives.
+    enter(node) {
+      if (!("directives" in node) || !node.directives) {
+        return;
+      }
+      let seenDirectives;
+      if (node.kind === Kind.SCHEMA_DEFINITION || node.kind === Kind.SCHEMA_EXTENSION) {
+        seenDirectives = schemaDirectives;
+      } else if (isTypeDefinitionNode(node) || isTypeExtensionNode(node)) {
+        const typeName = node.name.value;
+        seenDirectives = typeDirectivesMap[typeName];
+        if (seenDirectives === void 0) {
+          typeDirectivesMap[typeName] = seenDirectives = /* @__PURE__ */ Object.create(null);
+        }
+      } else {
+        seenDirectives = /* @__PURE__ */ Object.create(null);
+      }
+      for (const directive of node.directives) {
+        const directiveName = directive.name.value;
+        if (uniqueDirectiveMap[directiveName]) {
+          if (seenDirectives[directiveName]) {
+            context.reportError(
+              new GraphQLError(
+                `The directive "@${directiveName}" can only be used once at this location.`,
+                {
+                  nodes: [seenDirectives[directiveName], directive]
+                }
+              )
+            );
+          } else {
+            seenDirectives[directiveName] = directive;
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  UniqueDirectivesPerLocationRule
+};
+//# sourceMappingURL=UniqueDirectivesPerLocationRule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UniqueDirectivesPerLocationRule.js","sources":["../../../../../node_modules/graphql/validation/rules/UniqueDirectivesPerLocationRule.mjs"],"sourcesContent":["import { GraphQLError } from '../../error/GraphQLError.mjs';\nimport { Kind } from '../../language/kinds.mjs';\nimport {\n  isTypeDefinitionNode,\n  isTypeExtensionNode,\n} from '../../language/predicates.mjs';\nimport { specifiedDirectives } from '../../type/directives.mjs';\n\n/**\n * Unique directive names per location\n *\n * A GraphQL document is only valid if all non-repeatable directives at\n * a given location are uniquely named.\n *\n * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location\n */\nexport function UniqueDirectivesPerLocationRule(context) {\n  const uniqueDirectiveMap = Object.create(null);\n  const schema = context.getSchema();\n  const definedDirectives = schema\n    ? schema.getDirectives()\n    : specifiedDirectives;\n\n  for (const directive of definedDirectives) {\n    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;\n  }\n\n  const astDefinitions = context.getDocument().definitions;\n\n  for (const def of astDefinitions) {\n    if (def.kind === Kind.DIRECTIVE_DEFINITION) {\n      uniqueDirectiveMap[def.name.value] = !def.repeatable;\n    }\n  }\n\n  const schemaDirectives = Object.create(null);\n  const typeDirectivesMap = Object.create(null);\n  return {\n    // Many different AST nodes may contain directives. Rather than listing\n    // them all, just listen for entering any node, and check to see if it\n    // defines any directives.\n    enter(node) {\n      if (!('directives' in node) || !node.directives) {\n        return;\n      }\n\n      let seenDirectives;\n\n      if (\n        node.kind === Kind.SCHEMA_DEFINITION ||\n        node.kind === Kind.SCHEMA_EXTENSION\n      ) {\n        seenDirectives = schemaDirectives;\n      } else if (isTypeDefinitionNode(node) || isTypeExtensionNode(node)) {\n        const typeName = node.name.value;\n        seenDirectives = typeDirectivesMap[typeName];\n\n        if (seenDirectives === undefined) {\n          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);\n        }\n      } else {\n        seenDirectives = Object.create(null);\n      }\n\n      for (const directive of node.directives) {\n        const directiveName = directive.name.value;\n\n        if (uniqueDirectiveMap[directiveName]) {\n          if (seenDirectives[directiveName]) {\n            context.reportError(\n              new GraphQLError(\n                `The directive \"@${directiveName}\" can only be used once at this location.`,\n                {\n                  nodes: [seenDirectives[directiveName], directive],\n                },\n              ),\n            );\n          } else {\n            seenDirectives[directiveName] = directive;\n          }\n        }\n      }\n    },\n  };\n}\n"],"names":[],"mappings":";;;;AAgBO,SAAS,gCAAgC,SAAS;AACvD,QAAM,qBAAqB,uBAAO,OAAO,IAAI;AAC7C,QAAM,SAAS,QAAQ,UAAS;AAChC,QAAM,oBAAoB,SACtB,OAAO,cAAa,IACpB;AAEJ,aAAW,aAAa,mBAAmB;AACzC,uBAAmB,UAAU,IAAI,IAAI,CAAC,UAAU;AAAA,EAClD;AAEA,QAAM,iBAAiB,QAAQ,YAAW,EAAG;AAE7C,aAAW,OAAO,gBAAgB;AAChC,QAAI,IAAI,SAAS,KAAK,sBAAsB;AAC1C,yBAAmB,IAAI,KAAK,KAAK,IAAI,CAAC,IAAI;AAAA,IAC5C;AAAA,EACF;AAEA,QAAM,mBAAmB,uBAAO,OAAO,IAAI;AAC3C,QAAM,oBAAoB,uBAAO,OAAO,IAAI;AAC5C,SAAO;AAAA;AAAA;AAAA;AAAA,IAIL,MAAM,MAAM;AACV,UAAI,EAAE,gBAAgB,SAAS,CAAC,KAAK,YAAY;AAC/C;AAAA,MACF;AAEA,UAAI;AAEJ,UACE,KAAK,SAAS,KAAK,qBACnB,KAAK,SAAS,KAAK,kBACnB;AACA,yBAAiB;AAAA,MACnB,WAAW,qBAAqB,IAAI,KAAK,oBAAoB,IAAI,GAAG;AAClE,cAAM,WAAW,KAAK,KAAK;AAC3B,yBAAiB,kBAAkB,QAAQ;AAE3C,YAAI,mBAAmB,QAAW;AAChC,4BAAkB,QAAQ,IAAI,iBAAiB,uBAAO,OAAO,IAAI;AAAA,QACnE;AAAA,MACF,OAAO;AACL,yBAAiB,uBAAO,OAAO,IAAI;AAAA,MACrC;AAEA,iBAAW,aAAa,KAAK,YAAY;AACvC,cAAM,gBAAgB,UAAU,KAAK;AAErC,YAAI,mBAAmB,aAAa,GAAG;AACrC,cAAI,eAAe,aAAa,GAAG;AACjC,oBAAQ;AAAA,cACN,IAAI;AAAA,gBACF,mBAAmB,aAAa;AAAA,gBAChC;AAAA,kBACE,OAAO,CAAC,eAAe,aAAa,GAAG,SAAS;AAAA,gBAClE;AAAA,cACA;AAAA,YACA;AAAA,UACU,OAAO;AACL,2BAAe,aAAa,IAAI;AAAA,UAClC;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACJ;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,50 @@
+import { GraphQLError } from "../../error/GraphQLError.js";
+import { isEnumType } from "../../type/definition.js";
+function UniqueEnumValueNamesRule(context) {
+  const schema = context.getSchema();
+  const existingTypeMap = schema ? schema.getTypeMap() : /* @__PURE__ */ Object.create(null);
+  const knownValueNames = /* @__PURE__ */ Object.create(null);
+  return {
+    EnumTypeDefinition: checkValueUniqueness,
+    EnumTypeExtension: checkValueUniqueness
+  };
+  function checkValueUniqueness(node) {
+    var _node$values;
+    const typeName = node.name.value;
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = /* @__PURE__ */ Object.create(null);
+    }
+    const valueNodes = (_node$values = node.values) !== null && _node$values !== void 0 ? _node$values : [];
+    const valueNames = knownValueNames[typeName];
+    for (const valueDef of valueNodes) {
+      const valueName = valueDef.name.value;
+      const existingType = existingTypeMap[typeName];
+      if (isEnumType(existingType) && existingType.getValue(valueName)) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            {
+              nodes: valueDef.name
+            }
+          )
+        );
+      } else if (valueNames[valueName]) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" can only be defined once.`,
+            {
+              nodes: [valueNames[valueName], valueDef.name]
+            }
+          )
+        );
+      } else {
+        valueNames[valueName] = valueDef.name;
+      }
+    }
+    return false;
+  }
+}
+export {
+  UniqueEnumValueNamesRule
+};
+//# sourceMappingURL=UniqueEnumValueNamesRule.js.map