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

package/esm/rules/require-field-of-type-query-in-mutation-result.js

@@ -0,0 +1,68 @@
+import "../chunk-U3TKCM4X.js";
+import { isObjectType } from "graphql";
+import { getTypeName, requireGraphQLSchemaFromContext } from "../utils.js";
+const RULE_ID = "require-field-of-type-query-in-mutation-result", rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Schema",
+      description: "Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type User { ... }
+
+            type Mutation {
+              createUser: User!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type User { ... }
+
+            type Query { ... }
+
+            type CreateUserPayload {
+              user: User!
+              query: Query!
+            }
+
+            type Mutation {
+              createUser: CreateUserPayload!
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema: []
+  },
+  create(context) {
+    const schema = requireGraphQLSchemaFromContext(RULE_ID, context), mutationType = schema.getMutationType(), queryType = schema.getQueryType();
+    return !mutationType || !queryType ? {} : {
+      [`:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`](node) {
+        const typeName = node.value, graphQLType = schema.getType(typeName);
+        if (isObjectType(graphQLType)) {
+          const { fields } = graphQLType.astNode;
+          fields?.some((field) => getTypeName(field) === queryType.name) || context.report({
+            node,
+            message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`
+          });
+        }
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/require-import-fragment.d.mts

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

package/esm/rules/require-import-fragment.js

@@ -0,0 +1,121 @@
+import "../chunk-U3TKCM4X.js";
+import path from "node:path";
+import { requireSiblingsOperations } from "../utils.js";
+const RULE_ID = "require-import-fragment", SUGGESTION_ID = "add-import-expression", rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Require fragments to be imported via an import expression.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # import 'post-fields.fragment.graphql'
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # import UserFields from 'post-fields.fragment.graphql'
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # import UserFields from 'user-fields.fragment.graphql'
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        }
+      ],
+      requiresSiblings: !0
+    },
+    hasSuggestions: !0,
+    messages: {
+      [RULE_ID]: 'Expected "{{fragmentName}}" fragment to be imported.',
+      [SUGGESTION_ID]: 'Add import expression for "{{fragmentName}}".'
+    },
+    schema: []
+  },
+  create(context) {
+    const comments = context.getSourceCode().getAllComments(), siblings = requireSiblingsOperations(RULE_ID, context), filePath = context.filename;
+    return {
+      "FragmentSpread > .name"(node) {
+        const fragmentName = node.value, fragmentsFromSiblings = siblings.getFragment(fragmentName);
+        for (const comment of comments) {
+          if (comment.type !== "Line" || !new RegExp(
+            `^\\s*import\\s+(${fragmentName}\\s+from\\s+)?['"]`
+          ).test(comment.value))
+            continue;
+          const extractedImportPath = comment.value.match(/(["'])((?:\1|.)*?)\1/)?.[2];
+          if (!extractedImportPath)
+            continue;
+          const importPath = path.join(path.dirname(filePath), extractedImportPath);
+          if (fragmentsFromSiblings.some(
+            (source) => source.filePath === importPath
+          ))
+            return;
+        }
+        if (fragmentsFromSiblings.some(
+          (source) => source.filePath === filePath
+        ))
+          return;
+        const suggestedFilePaths = fragmentsFromSiblings.length ? fragmentsFromSiblings.map((o) => path.relative(path.dirname(filePath), o.filePath)) : ["CHANGE_ME.graphql"];
+        context.report({
+          node,
+          messageId: RULE_ID,
+          data: { fragmentName },
+          suggest: suggestedFilePaths.map((suggestedPath) => ({
+            messageId: SUGGESTION_ID,
+            data: { fragmentName },
+            fix: (fixer) => fixer.insertTextBeforeRange(
+              [0, 0],
+              `# import ${fragmentName} from '${suggestedPath}'
+`
+            )
+          }))
+        });
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/require-nullable-fields-with-oneof.d.mts

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

package/esm/rules/require-nullable-fields-with-oneof.js

@@ -0,0 +1,62 @@
+import "../chunk-U3TKCM4X.js";
+import { Kind } from "graphql";
+import { getNodeName } from "../utils.js";
+const RULE_ID = "require-nullable-fields-with-oneof", rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Schema",
+      description: "Require `input` or `type` fields to be non-nullable with `@oneOf` directive.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            input Input @oneOf {
+              foo: String!
+              b: Int
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            input Input @oneOf {
+              foo: String
+              bar: Int
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: '{{ nodeName }} must be nullable when "@oneOf" is in use'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      "Directive[name.value=oneOf]"({ parent }) {
+        if ([
+          Kind.OBJECT_TYPE_DEFINITION,
+          Kind.INPUT_OBJECT_TYPE_DEFINITION
+        ].includes(parent.kind))
+          for (const field of parent.fields || [])
+            field.gqlType.kind === Kind.NON_NULL_TYPE && context.report({
+              node: field.name,
+              messageId: RULE_ID,
+              data: { nodeName: getNodeName(field) }
+            });
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/require-nullable-result-in-root.d.mts

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

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

@@ -0,0 +1,80 @@
+import "../chunk-U3TKCM4X.js";
+import { Kind } from "graphql";
+import { getNodeName, requireGraphQLSchemaFromContext, truthy } from "../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 = requireGraphQLSchemaFromContext(RULE_ID, context), rootTypeNames = new Set(
+      [schema.getQueryType(), schema.getMutationType()].filter(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 !== Kind.NON_NULL_TYPE || field.gqlType.gqlType.type !== Kind.NAMED_TYPE)
+              continue;
+            const name = field.gqlType.gqlType.name.value, type = schema.getType(name), resultType = type?.astNode ? getNodeName(type.astNode) : type?.name;
+            context.report({
+              node: field.gqlType,
+              messageId: RULE_ID,
+              data: {
+                resultType: resultType || "",
+                rootType: getNodeName(node)
+              },
+              suggest: [
+                {
+                  desc: `Make ${resultType} nullable`,
+                  fix(fixer) {
+                    const text = sourceCode.getText(field.gqlType);
+                    return fixer.replaceText(field.gqlType, text.replace("!", ""));
+                  }
+                }
+              ]
+            });
+          }
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/require-selections.d.mts

@@ -0,0 +1,45 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.mjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import '../siblings.mjs';
+import '@graphql-tools/utils';
+import '../estree-converter/types.mjs';
+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/esm/rules/require-selections.js

@@ -0,0 +1,194 @@
+import "../chunk-U3TKCM4X.js";
+import { asArray } from "@graphql-tools/utils";
+import {
+  GraphQLInterfaceType,
+  GraphQLObjectType,
+  GraphQLUnionType,
+  Kind,
+  TypeInfo,
+  visit,
+  visitWithTypeInfo
+} from "graphql";
+import { getBaseType } from "../estree-converter/index.js";
+import {
+  ARRAY_DEFAULT_OPTIONS,
+  englishJoinWords,
+  requireGraphQLSchemaFromContext,
+  requireSiblingsOperations
+} from "../utils.js";
+const RULE_ID = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema = {
+  definitions: {
+    asString: {
+      type: "string"
+    },
+    asArray: 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 = requireGraphQLSchemaFromContext(RULE_ID, context), siblings = requireSiblingsOperations(RULE_ID, context), { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {}, idNames = asArray(fieldName), selector = "OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]", typeInfo = new TypeInfo(schema2);
+    function checkFragments(node) {
+      for (const selection of node.selections) {
+        if (selection.kind !== Kind.FRAGMENT_SPREAD)
+          continue;
+        const [foundSpread] = siblings.getFragment(selection.name.value);
+        if (!foundSpread)
+          continue;
+        const checkedFragmentSpreads = /* @__PURE__ */ new Set(), visitor = visitWithTypeInfo(typeInfo, {
+          SelectionSet(node2, key, _parent) {
+            const parent = _parent;
+            parent.kind === Kind.FRAGMENT_DEFINITION ? checkedFragmentSpreads.add(parent.name.value) : parent.kind !== Kind.INLINE_FRAGMENT && checkSelections(
+              node2,
+              typeInfo.getType(),
+              selection.loc.start,
+              parent,
+              checkedFragmentSpreads
+            );
+          }
+        });
+        visit(foundSpread.document, visitor);
+      }
+    }
+    function checkSelections(node, type, loc, parent, checkedFragmentSpreads = /* @__PURE__ */ new Set()) {
+      const rawType = getBaseType(type);
+      if (rawType instanceof GraphQLObjectType || rawType instanceof GraphQLInterfaceType)
+        checkFields(rawType);
+      else if (rawType instanceof GraphQLUnionType) {
+        for (const selection of node.selections)
+          if (selection.kind === 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 === Kind.FIELD)
+              return selection.alias && idNames.includes(selection.alias.value) ? !0 : idNames.includes(selection.name.value);
+            if (selection.kind === Kind.INLINE_FRAGMENT)
+              return hasIdField(selection.selectionSet);
+            if (selection.kind === 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 = englishJoinWords(
+          idNames.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
+        ), addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${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 === 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);
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/require-type-pattern-with-oneof.d.mts

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

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

@@ -0,0 +1,63 @@
+import "../chunk-U3TKCM4X.js";
+import { displayNodeName } from "../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: displayNodeName(parent),
+              fieldName
+            }
+          });
+      }
+    };
+  }
+};
+export {
+  rule
+};