@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230810155929-e89edf7

package/cjs/rules/require-nullable-result-in-root.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var require_nullable_result_in_root_exports = {};
+__export(require_nullable_result_in_root_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_nullable_result_in_root_exports);
+var import_graphql = require("graphql"), import_utils = require("../utils.js");
+const RULE_ID = "require-nullable-result-in-root", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      category: "Schema",
+      description: "Require nullable fields in root types.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type Query {
+              user: User!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type Query {
+              foo: User
+              baz: [User]!
+              bar: [User!]!
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: "Unexpected non-null result {{ resultType }} in {{ rootType }}"
+    },
+    schema: []
+  },
+  create(context) {
+    const schema = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context), rootTypeNames = new Set(
+      [schema.getQueryType(), schema.getMutationType()].filter(import_utils.truthy).map((type) => type.name)
+    ), sourceCode = context.getSourceCode();
+    return {
+      "ObjectTypeDefinition,ObjectTypeExtension"(node) {
+        if (rootTypeNames.has(node.name.value))
+          for (const field of node.fields || []) {
+            if (field.gqlType.type !== import_graphql.Kind.NON_NULL_TYPE || field.gqlType.gqlType.type !== import_graphql.Kind.NAMED_TYPE)
+              continue;
+            const name = field.gqlType.gqlType.name.value, type = schema.getType(name), resultType = type?.astNode ? (0, import_utils.getNodeName)(type.astNode) : type?.name;
+            context.report({
+              node: field.gqlType,
+              messageId: RULE_ID,
+              data: {
+                resultType: resultType || "",
+                rootType: (0, import_utils.getNodeName)(node)
+              },
+              suggest: [
+                {
+                  desc: `Make ${resultType} nullable`,
+                  fix(fixer) {
+                    const text = sourceCode.getText(field.gqlType);
+                    return fixer.replaceText(field.gqlType, text.replace("!", ""));
+                  }
+                }
+              ]
+            });
+          }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-selections.d.ts

@@ -0,0 +1,45 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+import 'graphql-config';
+
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly type: "string";
+        };
+        readonly asArray: {
+            readonly type: "array";
+            readonly uniqueItems: true;
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly fieldName: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asArray";
+                }];
+                readonly default: "id";
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions, true>;
+
+export { RuleOptions, rule };

package/cjs/rules/require-selections.js

@@ -0,0 +1,198 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var require_selections_exports = {};
+__export(require_selections_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_selections_exports);
+var import_utils = require("@graphql-tools/utils"), import_graphql = require("graphql"), import_estree_converter = require("../estree-converter/index.js"), import_utils2 = require("../utils.js");
+const RULE_ID = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema = {
+  definitions: {
+    asString: {
+      type: "string"
+    },
+    asArray: import_utils2.ARRAY_DEFAULT_OPTIONS
+  },
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    properties: {
+      fieldName: {
+        oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asArray" }],
+        default: DEFAULT_ID_FIELD_NAME
+      }
+    }
+  }
+}, rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      category: "Operations",
+      description: "Enforce selecting specific fields when they are available on the GraphQL type.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: !0,
+      requiresSiblings: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # In your schema
+            type User {
+              id: ID!
+              name: String!
+            }
+
+            # Query
+            query {
+              user {
+                name
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # In your schema
+            type User {
+              id: ID!
+              name: String!
+            }
+
+            # Query
+            query {
+              user {
+                id
+                name
+              }
+            }
+
+            # Selecting \`id\` with an alias is also valid
+            query {
+              user {
+                id: name
+              }
+            }
+          `
+          )
+        }
+      ],
+      recommended: !0
+    },
+    messages: {
+      [RULE_ID]: `Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.
+Include it in your selection set{{ addition }}.`
+    },
+    schema
+  },
+  create(context) {
+    const schema2 = (0, import_utils2.requireGraphQLSchemaFromContext)(RULE_ID, context), siblings = (0, import_utils2.requireSiblingsOperations)(RULE_ID, context), { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {}, idNames = (0, import_utils.asArray)(fieldName), selector = "OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]", typeInfo = new import_graphql.TypeInfo(schema2);
+    function checkFragments(node) {
+      for (const selection of node.selections) {
+        if (selection.kind !== import_graphql.Kind.FRAGMENT_SPREAD)
+          continue;
+        const [foundSpread] = siblings.getFragment(selection.name.value);
+        if (!foundSpread)
+          continue;
+        const checkedFragmentSpreads = /* @__PURE__ */ new Set(), visitor = (0, import_graphql.visitWithTypeInfo)(typeInfo, {
+          SelectionSet(node2, key, _parent) {
+            const parent = _parent;
+            parent.kind === import_graphql.Kind.FRAGMENT_DEFINITION ? checkedFragmentSpreads.add(parent.name.value) : parent.kind !== import_graphql.Kind.INLINE_FRAGMENT && checkSelections(
+              node2,
+              typeInfo.getType(),
+              selection.loc.start,
+              parent,
+              checkedFragmentSpreads
+            );
+          }
+        });
+        (0, import_graphql.visit)(foundSpread.document, visitor);
+      }
+    }
+    function checkSelections(node, type, loc, parent, checkedFragmentSpreads = /* @__PURE__ */ new Set()) {
+      const rawType = (0, import_estree_converter.getBaseType)(type);
+      if (rawType instanceof import_graphql.GraphQLObjectType || rawType instanceof import_graphql.GraphQLInterfaceType)
+        checkFields(rawType);
+      else if (rawType instanceof import_graphql.GraphQLUnionType) {
+        for (const selection of node.selections)
+          if (selection.kind === import_graphql.Kind.INLINE_FRAGMENT) {
+            const t = rawType.getTypes().find((t2) => t2.name === selection.typeCondition.name.value);
+            t && checkFields(t);
+          }
+      }
+      function checkFields(rawType2) {
+        const fields = rawType2.getFields();
+        if (!idNames.some((name) => fields[name]))
+          return;
+        function hasIdField({ selections }) {
+          return selections.some((selection) => {
+            if (selection.kind === import_graphql.Kind.FIELD)
+              return selection.alias && idNames.includes(selection.alias.value) ? !0 : idNames.includes(selection.name.value);
+            if (selection.kind === import_graphql.Kind.INLINE_FRAGMENT)
+              return hasIdField(selection.selectionSet);
+            if (selection.kind === import_graphql.Kind.FRAGMENT_SPREAD) {
+              const [foundSpread] = siblings.getFragment(selection.name.value);
+              if (foundSpread) {
+                const fragmentSpread = foundSpread.document;
+                return checkedFragmentSpreads.add(fragmentSpread.name.value), hasIdField(fragmentSpread.selectionSet);
+              }
+            }
+            return !1;
+          });
+        }
+        const hasId = hasIdField(node);
+        if (checkFragments(node), hasId)
+          return;
+        const pluralSuffix = idNames.length > 1 ? "s" : "", fieldName2 = (0, import_utils2.englishJoinWords)(
+          idNames.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
+        ), addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${(0, import_utils2.englishJoinWords)([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`, problem = {
+          loc,
+          messageId: RULE_ID,
+          data: {
+            pluralSuffix,
+            fieldName: fieldName2,
+            addition
+          }
+        };
+        "type" in node && (problem.suggest = idNames.map((idName) => ({
+          desc: `Add \`${idName}\` selection`,
+          fix: (fixer) => {
+            let insertNode = node.selections[0];
+            return insertNode = insertNode.kind === import_graphql.Kind.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode, fixer.insertTextBefore(insertNode, `${idName} `);
+          }
+        }))), context.report(problem);
+      }
+    }
+    return {
+      [selector](node) {
+        const typeInfo2 = node.typeInfo();
+        typeInfo2.gqlType && checkSelections(node, typeInfo2.gqlType, node.loc.start, node.parent);
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-type-pattern-with-oneof.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+import 'graphql-config';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

package/cjs/rules/require-type-pattern-with-oneof.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var require_type_pattern_with_oneof_exports = {};
+__export(require_type_pattern_with_oneof_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_type_pattern_with_oneof_exports);
+var import_utils = require("../utils.js");
+const RULE_ID = "require-type-pattern-with-oneof", rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Schema",
+      description: "Enforce types with `@oneOf` directive have `error` and `ok` fields.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              doSomething: DoSomethingMutationResult!
+            }
+
+            interface Error {
+              message: String!
+            }
+
+            type DoSomethingMutationResult @oneOf {
+              ok: DoSomethingSuccess
+              error: Error
+            }
+
+            type DoSomethingSuccess {
+              # ...
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: '{{ nodeName }} is defined as output with "@oneOf" and must be defined with "{{ fieldName }}" field'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      "Directive[name.value=oneOf][parent.kind=ObjectTypeDefinition]"({
+        parent
+      }) {
+        const requiredFields = ["error", "ok"];
+        for (const fieldName of requiredFields)
+          parent.fields?.some((field) => field.name.value === fieldName) || context.report({
+            node: parent.name,
+            messageId: RULE_ID,
+            data: {
+              nodeName: (0, import_utils.displayNodeName)(parent),
+              fieldName
+            }
+          });
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/selection-set-depth.d.ts

@@ -0,0 +1,37 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+import 'graphql-config';
+
+declare const schema: {
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["maxDepth"];
+        readonly properties: {
+            readonly maxDepth: {
+                readonly type: "number";
+            };
+            readonly ignore: {
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

package/cjs/rules/selection-set-depth.js

@@ -0,0 +1,159 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var selection_set_depth_exports = {};
+__export(selection_set_depth_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(selection_set_depth_exports);
+var import_graphql = require("graphql"), import_graphql_depth_limit = __toESM(require("graphql-depth-limit")), import_utils = require("../utils.js");
+const RULE_ID = "selection-set-depth", schema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    required: ["maxDepth"],
+    properties: {
+      maxDepth: {
+        type: "number"
+      },
+      ignore: import_utils.ARRAY_DEFAULT_OPTIONS
+    }
+  }
+}, rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      category: "Operations",
+      description: "Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ maxDepth: 1 }],
+          code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `
+        },
+        {
+          title: "Correct",
+          usage: [{ maxDepth: 4 }],
+          code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `
+        },
+        {
+          title: "Correct (ignored field)",
+          usage: [{ maxDepth: 1, ignore: ["albums"] }],
+          code: `
+            query deep2 {
+              viewer { # Level 0
+                albums { # Level 1
+                  title # Level 2
+                }
+              }
+            }
+          `
+        }
+      ],
+      recommended: !0,
+      configOptions: [{ maxDepth: 7 }]
+    },
+    schema
+  },
+  create(context) {
+    let siblings = null;
+    try {
+      siblings = (0, import_utils.requireSiblingsOperations)(RULE_ID, context);
+    } catch {
+      import_utils.logger.warn(
+        `Rule "${RULE_ID}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`
+      );
+    }
+    const { maxDepth, ignore = [] } = context.options[0], checkFn = (0, import_graphql_depth_limit.default)(maxDepth, { ignore });
+    return {
+      "OperationDefinition, FragmentDefinition"(node) {
+        try {
+          const rawNode = node.rawNode(), fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [], document = {
+            kind: import_graphql.Kind.DOCUMENT,
+            definitions: [rawNode, ...fragmentsInUse]
+          };
+          checkFn({
+            getDocument: () => document,
+            reportError(error) {
+              const { line, column } = error.locations[0], token = context.getAncestors()[0].tokens.find(
+                (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
+              );
+              context.report({
+                loc: {
+                  line,
+                  column: column - 1
+                },
+                message: error.message,
+                // Don't provide suggestions for fragment that can be in a separate file
+                ...token && {
+                  suggest: [
+                    {
+                      desc: "Remove selections",
+                      fix(fixer) {
+                        const foundNode = context.getSourceCode().getNodeByRangeIndex(token.range[0]), parentNode = foundNode.parent.parent;
+                        return fixer.remove(
+                          foundNode.kind === "Name" ? parentNode.parent : parentNode
+                        );
+                      }
+                    }
+                  ]
+                }
+              });
+            }
+          });
+        } catch (e) {
+          import_utils.logger.warn(
+            `Rule "${RULE_ID}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`,
+            e
+          );
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});