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

package/esm/rules/index.d.mts

@@ -0,0 +1,127 @@
+import { RuleOptions } from './require-description.mjs';
+import { CaseStyle } from '../utils.mjs';
+import * as graphql_language_ast_js from 'graphql/language/ast.js';
+import { GraphQLESLintRule } from '../types.mjs';
+import * as json_schema_to_ts_lib_types_type_utils_writable_js from 'json-schema-to-ts/lib/types/type-utils/writable.js';
+import 'graphql';
+import 'eslint';
+import 'estree';
+import '../siblings.mjs';
+import '@graphql-tools/utils';
+import '../estree-converter/types.mjs';
+import 'json-schema-to-ts';
+import 'graphql-config';
+
+declare const rules: {
+    alphabetize: GraphQLESLintRule<{
+        definitions?: boolean | undefined;
+        selections?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"OperationDefinition" | "FragmentDefinition">[] | undefined;
+        arguments?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition">[] | undefined;
+        values?: boolean | undefined;
+        fields?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition">[] | undefined;
+        variables?: boolean | undefined;
+        groups?: string[] | undefined;
+    }[]>;
+    'description-style': GraphQLESLintRule<{
+        style?: "block" | "inline" | undefined;
+    }[]>;
+    'input-name': GraphQLESLintRule<{
+        checkInputType?: boolean | undefined;
+        caseSensitiveInputType?: boolean | undefined;
+        checkQueries?: boolean | undefined;
+        checkMutations?: boolean | undefined;
+    }[]>;
+    'lone-executable-definition': GraphQLESLintRule<{
+        ignore?: ("fragment" | json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<graphql_language_ast_js.OperationTypeNode>)[] | undefined;
+    }[]>;
+    'match-document-filename': GraphQLESLintRule<{
+        fragment?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        mutation?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        subscription?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        query?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<CaseStyle | "matchDocumentStyle"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+        } | undefined;
+        fileExtension?: ".gql" | ".graphql" | undefined;
+    }[]>;
+    'naming-convention': GraphQLESLintRule<{
+        [x: string]: unknown;
+        types?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE"> | {
+            style?: json_schema_to_ts_lib_types_type_utils_writable_js.DeepWritable<"camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE"> | undefined;
+            suffix?: string | undefined;
+            prefix?: string | undefined;
+            forbiddenPrefixes?: string[] | undefined;
+            forbiddenSuffixes?: string[] | undefined;
+            requiredPrefixes?: string[] | undefined;
+            requiredSuffixes?: string[] | undefined;
+            ignorePattern?: string | undefined;
+        } | undefined;
+        allowLeadingUnderscore?: boolean | undefined;
+        allowTrailingUnderscore?: boolean | undefined;
+    }[]>;
+    'no-anonymous-operations': GraphQLESLintRule;
+    'no-deprecated': GraphQLESLintRule<[], true>;
+    'no-duplicate-fields': GraphQLESLintRule;
+    'no-hashtag-description': GraphQLESLintRule;
+    'no-one-place-fragments': GraphQLESLintRule;
+    'no-root-type': GraphQLESLintRule<{
+        disallow: ("mutation" | "subscription")[];
+    }[]>;
+    'no-scalar-result-type-on-mutation': GraphQLESLintRule;
+    'no-typename-prefix': GraphQLESLintRule;
+    'no-unreachable-types': GraphQLESLintRule;
+    'no-unused-fields': GraphQLESLintRule;
+    'relay-arguments': GraphQLESLintRule<{
+        includeBoth?: boolean | undefined;
+    }[], true>;
+    'relay-connection-types': GraphQLESLintRule;
+    'relay-edge-types': GraphQLESLintRule<{
+        withEdgeSuffix?: boolean | undefined;
+        shouldImplementNode?: boolean | undefined;
+        listTypeCanWrapOnlyEdgeType?: boolean | undefined;
+    }[], true>;
+    'relay-page-info': GraphQLESLintRule;
+    'require-deprecation-date': GraphQLESLintRule<{
+        argumentName?: string | undefined;
+    }[]>;
+    'require-deprecation-reason': GraphQLESLintRule;
+    'require-description': GraphQLESLintRule<RuleOptions>;
+    'require-field-of-type-query-in-mutation-result': GraphQLESLintRule;
+    'require-import-fragment': GraphQLESLintRule;
+    'require-nullable-fields-with-oneof': GraphQLESLintRule;
+    'require-nullable-result-in-root': GraphQLESLintRule;
+    'require-selections': GraphQLESLintRule<{
+        fieldName?: string | string[] | undefined;
+    }[], true>;
+    'require-type-pattern-with-oneof': GraphQLESLintRule;
+    'selection-set-depth': GraphQLESLintRule<{
+        ignore?: string[] | undefined;
+        maxDepth: number;
+    }[]>;
+    'strict-id-in-types': GraphQLESLintRule<{
+        acceptedIdNames?: string[] | undefined;
+        acceptedIdTypes?: string[] | undefined;
+        exceptions?: {
+            types?: string[] | undefined;
+            suffixes?: string[] | undefined;
+        } | undefined;
+    }[]>;
+    'unique-enum-value-names': GraphQLESLintRule;
+    'unique-fragment-name': GraphQLESLintRule;
+    'unique-operation-name': GraphQLESLintRule;
+};
+
+export { rules };

package/esm/rules/index.js

@@ -0,0 +1,76 @@
+import "../chunk-U3TKCM4X.js";
+import { GRAPHQL_JS_VALIDATIONS } from "./graphql-js-validation.js";
+import { rule as alphabetize } from "./alphabetize.js";
+import { rule as descriptionStyle } from "./description-style.js";
+import { rule as inputName } from "./input-name.js";
+import { rule as loneExecutableDefinition } from "./lone-executable-definition.js";
+import { rule as matchDocumentFilename } from "./match-document-filename.js";
+import { rule as namingConvention } from "./naming-convention.js";
+import { rule as noAnonymousOperations } from "./no-anonymous-operations.js";
+import { rule as noDeprecated } from "./no-deprecated.js";
+import { rule as noDuplicateFields } from "./no-duplicate-fields.js";
+import { rule as noHashtagDescription } from "./no-hashtag-description.js";
+import { rule as noOnePlaceFragments } from "./no-one-place-fragments.js";
+import { rule as noRootType } from "./no-root-type.js";
+import { rule as noScalarResultTypeOnMutation } from "./no-scalar-result-type-on-mutation.js";
+import { rule as noTypenamePrefix } from "./no-typename-prefix.js";
+import { rule as noUnreachableTypes } from "./no-unreachable-types.js";
+import { rule as noUnusedFields } from "./no-unused-fields.js";
+import { rule as relayArguments } from "./relay-arguments.js";
+import { rule as relayConnectionTypes } from "./relay-connection-types.js";
+import { rule as relayEdgeTypes } from "./relay-edge-types.js";
+import { rule as relayPageInfo } from "./relay-page-info.js";
+import { rule as requireDeprecationDate } from "./require-deprecation-date.js";
+import { rule as requireDeprecationReason } from "./require-deprecation-reason.js";
+import { rule as requireDescription } from "./require-description.js";
+import { rule as requireFieldOfTypeQueryInMutationResult } from "./require-field-of-type-query-in-mutation-result.js";
+import { rule as requireImportFragment } from "./require-import-fragment.js";
+import { rule as requireNullableFieldsWithOneof } from "./require-nullable-fields-with-oneof.js";
+import { rule as requireNullableResultInRoot } from "./require-nullable-result-in-root.js";
+import { rule as requireSelections } from "./require-selections.js";
+import { rule as requireTypePatternWithOneof } from "./require-type-pattern-with-oneof.js";
+import { rule as selectionSetDepth } from "./selection-set-depth.js";
+import { rule as strictIdInTypes } from "./strict-id-in-types.js";
+import { rule as uniqueEnumValueNames } from "./unique-enum-value-names.js";
+import { rule as uniqueFragmentName } from "./unique-fragment-name.js";
+import { rule as uniqueOperationName } from "./unique-operation-name.js";
+const rules = {
+  ...GRAPHQL_JS_VALIDATIONS,
+  alphabetize,
+  "description-style": descriptionStyle,
+  "input-name": inputName,
+  "lone-executable-definition": loneExecutableDefinition,
+  "match-document-filename": matchDocumentFilename,
+  "naming-convention": namingConvention,
+  "no-anonymous-operations": noAnonymousOperations,
+  "no-deprecated": noDeprecated,
+  "no-duplicate-fields": noDuplicateFields,
+  "no-hashtag-description": noHashtagDescription,
+  "no-one-place-fragments": noOnePlaceFragments,
+  "no-root-type": noRootType,
+  "no-scalar-result-type-on-mutation": noScalarResultTypeOnMutation,
+  "no-typename-prefix": noTypenamePrefix,
+  "no-unreachable-types": noUnreachableTypes,
+  "no-unused-fields": noUnusedFields,
+  "relay-arguments": relayArguments,
+  "relay-connection-types": relayConnectionTypes,
+  "relay-edge-types": relayEdgeTypes,
+  "relay-page-info": relayPageInfo,
+  "require-deprecation-date": requireDeprecationDate,
+  "require-deprecation-reason": requireDeprecationReason,
+  "require-description": requireDescription,
+  "require-field-of-type-query-in-mutation-result": requireFieldOfTypeQueryInMutationResult,
+  "require-import-fragment": requireImportFragment,
+  "require-nullable-fields-with-oneof": requireNullableFieldsWithOneof,
+  "require-nullable-result-in-root": requireNullableResultInRoot,
+  "require-selections": requireSelections,
+  "require-type-pattern-with-oneof": requireTypePatternWithOneof,
+  "selection-set-depth": selectionSetDepth,
+  "strict-id-in-types": strictIdInTypes,
+  "unique-enum-value-names": uniqueEnumValueNames,
+  "unique-fragment-name": uniqueFragmentName,
+  "unique-operation-name": uniqueOperationName
+};
+export {
+  rules
+};

package/esm/rules/input-name.d.mts

@@ -0,0 +1,44 @@
+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 type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly checkInputType: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "Check that the input type name follows the convention \\<mutationName>Input";
+            };
+            readonly caseSensitiveInputType: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Allow for case discrepancies in the input type name";
+            };
+            readonly checkQueries: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "Apply the rule to Queries";
+            };
+            readonly checkMutations: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Apply the rule to Mutations";
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

package/esm/rules/input-name.js

@@ -0,0 +1,136 @@
+import "../chunk-U3TKCM4X.js";
+import {
+  Kind
+} from "graphql";
+const schema = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    properties: {
+      checkInputType: {
+        type: "boolean",
+        default: !1,
+        description: "Check that the input type name follows the convention \\<mutationName>Input"
+      },
+      caseSensitiveInputType: {
+        type: "boolean",
+        default: !0,
+        description: "Allow for case discrepancies in the input type name"
+      },
+      checkQueries: {
+        type: "boolean",
+        default: !1,
+        description: "Apply the rule to Queries"
+      },
+      checkMutations: {
+        type: "boolean",
+        default: !0,
+        description: "Apply the rule to Mutations"
+      }
+    }
+  }
+}, isObjectType = (node) => (
+  // TODO: remove `as any` when drop support of graphql@15
+  [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type)
+), isQueryType = (node) => isObjectType(node) && node.name.value === "Query", isMutationType = (node) => isObjectType(node) && node.name.value === "Mutation", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      description: `Require mutation argument to be always called "input" and input type to be called Mutation name + "Input".
+Using the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to.`,
+      category: "Schema",
+      url: "https://the-guild.dev/graphql/eslint/rules/input-name",
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ checkInputType: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              SetMessage(message: InputMessage): String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct (with `checkInputType`)",
+          usage: [{ checkInputType: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              SetMessage(input: SetMessageInput): String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct (without `checkInputType`)",
+          usage: [{ checkInputType: !1 }],
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              SetMessage(input: AnyInputTypeName): String
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema
+  },
+  create(context) {
+    const options = {
+      checkInputType: !1,
+      caseSensitiveInputType: !0,
+      checkMutations: !0,
+      ...context.options[0]
+    }, shouldCheckType = (node) => options.checkMutations && isMutationType(node) || options.checkQueries && isQueryType(node) || !1, listeners = {
+      "FieldDefinition > InputValueDefinition[name.value!=input] > Name"(node) {
+        const fieldDef = node.parent.parent;
+        if (shouldCheckType(fieldDef.parent)) {
+          const inputName = node.value;
+          context.report({
+            node,
+            message: `Input "${inputName}" should be named "input" for "${fieldDef.parent.name.value}.${fieldDef.name.value}"`,
+            suggest: [
+              {
+                desc: "Rename to `input`",
+                fix: (fixer) => fixer.replaceText(node, "input")
+              }
+            ]
+          });
+        }
+      }
+    };
+    return options.checkInputType && (listeners["FieldDefinition > InputValueDefinition NamedType"] = (node) => {
+      const inputValueNode = ((item) => {
+        let currentNode = item;
+        for (; currentNode.type !== Kind.INPUT_VALUE_DEFINITION; )
+          currentNode = currentNode.parent;
+        return currentNode;
+      })(node);
+      if (shouldCheckType(inputValueNode.parent.parent)) {
+        const mutationName = `${inputValueNode.parent.name.value}Input`, name = node.name.value;
+        (options.caseSensitiveInputType && node.name.value !== mutationName || name.toLowerCase() !== mutationName.toLowerCase()) && context.report({
+          node: node.name,
+          message: `Input type \`${name}\` name should be \`${mutationName}\`.`,
+          suggest: [
+            {
+              desc: `Rename to \`${mutationName}\``,
+              fix: (fixer) => fixer.replaceText(node, mutationName)
+            }
+          ]
+        });
+      }
+    }), listeners;
+  }
+};
+export {
+  rule
+};

package/esm/rules/lone-executable-definition.d.mts

@@ -0,0 +1,35 @@
+import { OperationTypeNode } from 'graphql';
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.mjs';
+import 'eslint';
+import 'estree';
+import '../siblings.mjs';
+import '@graphql-tools/utils';
+import '../estree-converter/types.mjs';
+import 'graphql-config';
+
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly minProperties: 1;
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly ignore: {
+                readonly maxItems: 3;
+                readonly items: {
+                    readonly enum: readonly ["fragment", ...OperationTypeNode[]];
+                };
+                readonly description: "Allow certain definitions to be placed alongside others.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

package/esm/rules/lone-executable-definition.js

@@ -0,0 +1,86 @@
+import "../chunk-U3TKCM4X.js";
+import { OperationTypeNode } from "graphql";
+import { ARRAY_DEFAULT_OPTIONS, getLocation, pascalCase } from "../utils.js";
+const RULE_ID = "lone-executable-definition", definitionTypes = ["fragment", ...Object.values(OperationTypeNode)], schema = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    minProperties: 1,
+    additionalProperties: !1,
+    properties: {
+      ignore: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        maxItems: 3,
+        // ignore all 4 types is redundant
+        items: {
+          enum: definitionTypes
+        },
+        description: "Allow certain definitions to be placed alongside others."
+      }
+    }
+  }
+}, rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Require queries, mutations, subscriptions or fragments to be located in separate files.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            query Foo {
+              id
+            }
+            fragment Bar on Baz {
+              id
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            query Foo {
+              id
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: "{{name}} should be in a separate file."
+    },
+    schema
+  },
+  create(context) {
+    const ignore = new Set(context.options[0]?.ignore || []), definitions = [];
+    return {
+      ":matches(OperationDefinition, FragmentDefinition)"(node) {
+        const type = "operation" in node ? node.operation : "fragment";
+        ignore.has(type) || definitions.push({ type, node });
+      },
+      "Document:exit"() {
+        for (const { node, type } of definitions.slice(1)) {
+          let name = pascalCase(type);
+          const definitionName = node.name?.value;
+          definitionName && (name += ` "${definitionName}"`), context.report({
+            loc: node.name?.loc || getLocation(node.loc.start, type),
+            messageId: RULE_ID,
+            data: { name }
+          });
+        }
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/match-document-filename.d.mts

@@ -0,0 +1,81 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.mjs';
+import { CaseStyle as CaseStyle$1 } from '../utils.mjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import '../siblings.mjs';
+import '@graphql-tools/utils';
+import '../estree-converter/types.mjs';
+import 'graphql-config';
+
+type CaseStyle = CaseStyle$1 | 'matchDocumentStyle';
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly enum: CaseStyle[];
+            readonly description: `One of: ${string}`;
+        };
+        readonly asObject: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly minProperties: 1;
+            readonly properties: {
+                readonly style: {
+                    readonly enum: CaseStyle[];
+                };
+                readonly suffix: {
+                    readonly type: "string";
+                };
+                readonly prefix: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly fileExtension: {
+                readonly enum: readonly [".gql", ".graphql"];
+            };
+            readonly query: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly mutation: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly subscription: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly fragment: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };