@graphql-eslint/eslint-plugin 3.19.3 → 3.20.0-alpha-20230703155329-a20556f

package/esm/rules/relay-arguments.js

@@ -1,119 +1,124 @@
-import { isScalarType, Kind } from 'graphql';
-import { requireGraphQLSchemaFromContext } from '../utils.js';
-const RULE_ID = 'relay-arguments';
-const MISSING_ARGUMENTS = 'MISSING_ARGUMENTS';
+import { isScalarType, Kind } from "graphql";
+import { requireGraphQLSchemaFromContext } from "../utils.js";
+const RULE_ID = "relay-arguments";
+const MISSING_ARGUMENTS = "MISSING_ARGUMENTS";
 const schema = {
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        minProperties: 1,
-        properties: {
-            includeBoth: {
-                type: 'boolean',
-                default: true,
-                description: 'Enforce including both forward and backward pagination arguments',
-            },
-        },
-    },
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    minProperties: 1,
+    properties: {
+      includeBoth: {
+        type: "boolean",
+        default: true,
+        description: "Enforce including both forward and backward pagination arguments"
+      }
+    }
+  }
 };
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            category: 'Schema',
-            description: [
-                'Set of rules to follow Relay specification for Arguments.',
-                '',
-                '- A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both',
-                '',
-                'Forward pagination arguments',
-                '',
-                '- `first` takes a non-negative integer',
-                '- `after` takes the Cursor type',
-                '',
-                'Backward pagination arguments',
-                '',
-                '- `last` takes a non-negative integer',
-                '- `before` takes the Cursor type',
-            ].join('\n'),
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      category: "Schema",
+      description: [
+        "Set of rules to follow Relay specification for Arguments.",
+        "",
+        "- A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both",
+        "",
+        "Forward pagination arguments",
+        "",
+        "- `first` takes a non-negative integer",
+        "- `after` takes the Cursor type",
+        "",
+        "Backward pagination arguments",
+        "",
+        "- `last` takes a non-negative integer",
+        "- `before` takes the Cursor type"
+      ].join("\n"),
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             type User {
               posts: PostConnection
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             type User {
               posts(after: String, first: Int, before: String, last: Int): PostConnection
             }
-          `,
-                },
-            ],
-            isDisabledForAllConfig: true,
-        },
-        messages: {
-            [MISSING_ARGUMENTS]: 'A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both.',
-        },
-        schema,
+          `
+          )
+        }
+      ],
+      isDisabledForAllConfig: true
     },
-    create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
-        const { includeBoth = true } = context.options[0] || {};
-        return {
-            'FieldDefinition > .gqlType Name[value=/Connection$/]'(node) {
-                var _a;
-                let fieldNode = node.parent;
-                while (fieldNode.kind !== Kind.FIELD_DEFINITION) {
-                    fieldNode = fieldNode.parent;
-                }
-                const args = Object.fromEntries(((_a = fieldNode.arguments) === null || _a === void 0 ? void 0 : _a.map(argument => [argument.name.value, argument])) || []);
-                const hasForwardPagination = !!(args.first && args.after);
-                const hasBackwardPagination = !!(args.last && args.before);
-                if (!hasForwardPagination && !hasBackwardPagination) {
-                    context.report({
-                        node: fieldNode.name,
-                        messageId: MISSING_ARGUMENTS,
-                    });
-                    return;
-                }
-                function checkField(typeName, argumentName) {
-                    const argument = args[argumentName];
-                    const hasArgument = !!argument;
-                    let type = argument;
-                    if (hasArgument && type.gqlType.kind === Kind.NON_NULL_TYPE) {
-                        type = type.gqlType;
-                    }
-                    const isAllowedNonNullType = hasArgument &&
-                        type.gqlType.kind === Kind.NAMED_TYPE &&
-                        (type.gqlType.name.value === typeName ||
-                            (typeName === 'String' && isScalarType(schema.getType(type.gqlType.name.value))));
-                    if (!isAllowedNonNullType) {
-                        const returnType = typeName === 'String' ? 'String or Scalar' : typeName;
-                        context.report({
-                            node: (argument || fieldNode).name,
-                            message: hasArgument
-                                ? `Argument \`${argumentName}\` must return ${returnType}.`
-                                : `Field \`${fieldNode.name.value}\` must contain an argument \`${argumentName}\`, that return ${returnType}.`,
-                        });
-                    }
-                }
-                if (includeBoth || args.first || args.after) {
-                    checkField('Int', 'first');
-                    checkField('String', 'after');
-                }
-                if (includeBoth || args.last || args.before) {
-                    checkField('Int', 'last');
-                    checkField('String', 'before');
-                }
-            },
-        };
+    messages: {
+      [MISSING_ARGUMENTS]: "A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both."
     },
+    schema
+  },
+  create(context) {
+    const schema2 = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const { includeBoth = true } = context.options[0] || {};
+    return {
+      "FieldDefinition > .gqlType Name[value=/Connection$/]"(node) {
+        let fieldNode = node.parent;
+        while (fieldNode.kind !== Kind.FIELD_DEFINITION) {
+          fieldNode = fieldNode.parent;
+        }
+        const args = Object.fromEntries(
+          fieldNode.arguments?.map((argument) => [argument.name.value, argument]) || []
+        );
+        const hasForwardPagination = !!(args.first && args.after);
+        const hasBackwardPagination = !!(args.last && args.before);
+        if (!hasForwardPagination && !hasBackwardPagination) {
+          context.report({
+            node: fieldNode.name,
+            messageId: MISSING_ARGUMENTS
+          });
+          return;
+        }
+        function checkField(typeName, argumentName) {
+          const argument = args[argumentName];
+          const hasArgument = !!argument;
+          let type = argument;
+          if (hasArgument && type.gqlType.kind === Kind.NON_NULL_TYPE) {
+            type = type.gqlType;
+          }
+          const isAllowedNonNullType = hasArgument && type.gqlType.kind === Kind.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && isScalarType(schema2.getType(type.gqlType.name.value)));
+          if (!isAllowedNonNullType) {
+            const returnType = typeName === "String" ? "String or Scalar" : typeName;
+            context.report({
+              node: (argument || fieldNode).name,
+              message: hasArgument ? `Argument \`${argumentName}\` must return ${returnType}.` : `Field \`${fieldNode.name.value}\` must contain an argument \`${argumentName}\`, that return ${returnType}.`
+            });
+          }
+        }
+        if (includeBoth || args.first || args.after) {
+          checkField("Int", "first");
+          checkField("String", "after");
+        }
+        if (includeBoth || args.last || args.before) {
+          checkField("Int", "last");
+          checkField("String", "before");
+        }
+      }
+    };
+  }
+};
+export {
+  rule
 };

package/esm/rules/relay-connection-types.d.mts

@@ -0,0 +1,13 @@
+import { Kind } from 'graphql';
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.mjs';
+
+declare const NON_OBJECT_TYPES: Kind[];
+declare const rule: GraphQLESLintRule;
+
+export { NON_OBJECT_TYPES, rule };

package/esm/rules/relay-connection-types.js

@@ -1,104 +1,111 @@
-import { Kind } from 'graphql';
-const MUST_BE_OBJECT_TYPE = 'MUST_BE_OBJECT_TYPE';
-const MUST_CONTAIN_FIELD_EDGES = 'MUST_CONTAIN_FIELD_EDGES';
-const MUST_CONTAIN_FIELD_PAGE_INFO = 'MUST_CONTAIN_FIELD_PAGE_INFO';
-const MUST_HAVE_CONNECTION_SUFFIX = 'MUST_HAVE_CONNECTION_SUFFIX';
-const EDGES_FIELD_MUST_RETURN_LIST_TYPE = 'EDGES_FIELD_MUST_RETURN_LIST_TYPE';
-const PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = 'PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE';
-export const NON_OBJECT_TYPES = [
-    Kind.SCALAR_TYPE_DEFINITION,
-    Kind.UNION_TYPE_DEFINITION,
-    Kind.UNION_TYPE_EXTENSION,
-    Kind.INPUT_OBJECT_TYPE_DEFINITION,
-    Kind.INPUT_OBJECT_TYPE_EXTENSION,
-    Kind.ENUM_TYPE_DEFINITION,
-    Kind.ENUM_TYPE_EXTENSION,
-    Kind.INTERFACE_TYPE_DEFINITION,
-    Kind.INTERFACE_TYPE_EXTENSION,
+import { Kind } from "graphql";
+const MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE";
+const MUST_CONTAIN_FIELD_EDGES = "MUST_CONTAIN_FIELD_EDGES";
+const MUST_CONTAIN_FIELD_PAGE_INFO = "MUST_CONTAIN_FIELD_PAGE_INFO";
+const MUST_HAVE_CONNECTION_SUFFIX = "MUST_HAVE_CONNECTION_SUFFIX";
+const EDGES_FIELD_MUST_RETURN_LIST_TYPE = "EDGES_FIELD_MUST_RETURN_LIST_TYPE";
+const PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = "PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE";
+const NON_OBJECT_TYPES = [
+  Kind.SCALAR_TYPE_DEFINITION,
+  Kind.UNION_TYPE_DEFINITION,
+  Kind.UNION_TYPE_EXTENSION,
+  Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  Kind.INPUT_OBJECT_TYPE_EXTENSION,
+  Kind.ENUM_TYPE_DEFINITION,
+  Kind.ENUM_TYPE_EXTENSION,
+  Kind.INTERFACE_TYPE_DEFINITION,
+  Kind.INTERFACE_TYPE_EXTENSION
 ];
 const notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`;
-const hasEdgesField = (node) => { var _a; return (_a = node.fields) === null || _a === void 0 ? void 0 : _a.some(field => field.name.value === 'edges'); };
-const hasPageInfoField = (node) => { var _a; return (_a = node.fields) === null || _a === void 0 ? void 0 : _a.some(field => field.name.value === 'pageInfo'); };
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            category: 'Schema',
-            description: [
-                'Set of rules to follow Relay specification for Connection types.',
-                '',
-                '- Any type whose name ends in "Connection" is considered by spec to be a `Connection type`',
-                '- Connection type must be an Object type',
-                '- Connection type must contain a field `edges` that return a list type that wraps an edge type',
-                '- Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type',
-            ].join('\n'),
-            url: 'https://the-guild.dev/graphql/eslint/rules/relay-connection-types',
-            isDisabledForAllConfig: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+const hasEdgesField = (node) => node.fields?.some((field) => field.name.value === "edges");
+const hasPageInfoField = (node) => node.fields?.some((field) => field.name.value === "pageInfo");
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      category: "Schema",
+      description: [
+        "Set of rules to follow Relay specification for Connection types.",
+        "",
+        '- Any type whose name ends in "Connection" is considered by spec to be a `Connection type`',
+        "- Connection type must be an Object type",
+        "- Connection type must contain a field `edges` that return a list type that wraps an edge type",
+        "- Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type"
+      ].join("\n"),
+      url: "https://the-guild.dev/graphql/eslint/rules/relay-connection-types",
+      isDisabledForAllConfig: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             type UserPayload { # should be an Object type with \`Connection\` suffix
               edges: UserEdge! # should return a list type
               pageInfo: PageInfo # should return a non-null \`PageInfo\` Object type
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             type UserConnection {
               edges: [UserEdge]
               pageInfo: PageInfo!
             }
-          `,
-                },
-            ],
-        },
-        messages: {
-            // Connection types
-            [MUST_BE_OBJECT_TYPE]: 'Connection type must be an Object type.',
-            [MUST_HAVE_CONNECTION_SUFFIX]: 'Connection type must have `Connection` suffix.',
-            [MUST_CONTAIN_FIELD_EDGES]: 'Connection type must contain a field `edges` that return a list type.',
-            [MUST_CONTAIN_FIELD_PAGE_INFO]: 'Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type.',
-            [EDGES_FIELD_MUST_RETURN_LIST_TYPE]: '`edges` field must return a list type.',
-            [PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE]: '`pageInfo` field must return a non-null `PageInfo` Object type.',
-        },
-        schema: [],
+          `
+          )
+        }
+      ]
     },
-    create(context) {
-        return {
-            [notConnectionTypesSelector](node) {
-                context.report({ node, messageId: MUST_BE_OBJECT_TYPE });
-            },
-            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value!=/Connection$/]'(node) {
-                if (hasEdgesField(node) && hasPageInfoField(node)) {
-                    context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
-                }
-            },
-            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/]'(node) {
-                if (!hasEdgesField(node)) {
-                    context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES });
-                }
-                if (!hasPageInfoField(node)) {
-                    context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
-                }
-            },
-            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType'(node) {
-                const isListType = node.kind === Kind.LIST_TYPE ||
-                    (node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.LIST_TYPE);
-                if (!isListType) {
-                    context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
-                }
-            },
-            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=pageInfo] > .gqlType'(node) {
-                const isNonNullPageInfoType = node.kind === Kind.NON_NULL_TYPE &&
-                    node.gqlType.kind === Kind.NAMED_TYPE &&
-                    node.gqlType.name.value === 'PageInfo';
-                if (!isNonNullPageInfoType) {
-                    context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
-                }
-            },
-        };
+    messages: {
+      // Connection types
+      [MUST_BE_OBJECT_TYPE]: "Connection type must be an Object type.",
+      [MUST_HAVE_CONNECTION_SUFFIX]: "Connection type must have `Connection` suffix.",
+      [MUST_CONTAIN_FIELD_EDGES]: "Connection type must contain a field `edges` that return a list type.",
+      [MUST_CONTAIN_FIELD_PAGE_INFO]: "Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type.",
+      [EDGES_FIELD_MUST_RETURN_LIST_TYPE]: "`edges` field must return a list type.",
+      [PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE]: "`pageInfo` field must return a non-null `PageInfo` Object type."
     },
+    schema: []
+  },
+  create(context) {
+    return {
+      [notConnectionTypesSelector](node) {
+        context.report({ node, messageId: MUST_BE_OBJECT_TYPE });
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value!=/Connection$/]"(node) {
+        if (hasEdgesField(node) && hasPageInfoField(node)) {
+          context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
+        }
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/]"(node) {
+        if (!hasEdgesField(node)) {
+          context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES });
+        }
+        if (!hasPageInfoField(node)) {
+          context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
+        }
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType"(node) {
+        const isListType = node.kind === Kind.LIST_TYPE || node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.LIST_TYPE;
+        if (!isListType) {
+          context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
+        }
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=pageInfo] > .gqlType"(node) {
+        const isNonNullPageInfoType = node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.NAMED_TYPE && node.gqlType.name.value === "PageInfo";
+        if (!isNonNullPageInfoType) {
+          context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+        }
+      }
+    };
+  }
+};
+export {
+  NON_OBJECT_TYPES,
+  rule
 };

package/{typings/rules/relay-edge-types.d.cts → esm/rules/relay-edge-types.d.mts}

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.cjs';
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.mjs';
+
 declare const schema: {
     readonly type: "array";
     readonly maxItems: 1;
@@ -26,6 +33,7 @@ declare const schema: {
         };
     };
 };
-export type RuleOptions = FromSchema<typeof schema>;
-export declare const rule: GraphQLESLintRule<RuleOptions, true>;
-export {};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions, true>;
+
+export { RuleOptions, rule };