@graphql-eslint/eslint-plugin 3.19.3-alpha-20230702093957-98f7783 → 3.20.0-alpha-20230703154330-0d51273

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

@@ -1,59 +1,68 @@
-import { Kind } from 'graphql';
-import { getNodeName } from '../utils.js';
-const RULE_ID = 'require-nullable-fields-with-oneof';
-export const 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 */ `
+import { Kind } from "graphql";
+import { getNodeName } from "../utils.js";
+const RULE_ID = "require-nullable-fields-with-oneof";
+const 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 */ `
+          `
+          )
+        },
+        {
+          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 }) {
-                const isTypeOrInput = [
-                    Kind.OBJECT_TYPE_DEFINITION,
-                    Kind.INPUT_OBJECT_TYPE_DEFINITION,
-                ].includes(parent.kind);
-                if (!isTypeOrInput) {
-                    return;
-                }
-                for (const field of parent.fields || []) {
-                    if (field.gqlType.kind === Kind.NON_NULL_TYPE) {
-                        context.report({
-                            node: field.name,
-                            messageId: RULE_ID,
-                            data: { nodeName: getNodeName(field) },
-                        });
-                    }
-                }
-            },
-        };
+    messages: {
+      [RULE_ID]: '{{ nodeName }} must be nullable when "@oneOf" is in use'
     },
+    schema: []
+  },
+  create(context) {
+    return {
+      "Directive[name.value=oneOf]"({ parent }) {
+        const isTypeOrInput = [
+          Kind.OBJECT_TYPE_DEFINITION,
+          Kind.INPUT_OBJECT_TYPE_DEFINITION
+        ].includes(parent.kind);
+        if (!isTypeOrInput) {
+          return;
+        }
+        for (const field of parent.fields || []) {
+          if (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,12 @@
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.mjs';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

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

@@ -1,77 +1,85 @@
-import { Kind } from 'graphql';
-import { getNodeName, requireGraphQLSchemaFromContext, truthy } from '../utils.js';
-const RULE_ID = 'require-nullable-result-in-root';
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        hasSuggestions: true,
-        docs: {
-            category: 'Schema',
-            description: 'Require nullable fields in root types.',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSchema: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+import { Kind } from "graphql";
+import { getNodeName, requireGraphQLSchemaFromContext, truthy } from "../utils.js";
+const RULE_ID = "require-nullable-result-in-root";
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      category: "Schema",
+      description: "Require nullable fields in root types.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             type Query {
               user: User!
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          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);
-        const rootTypeNames = new Set([schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]
-            .filter(truthy)
-            .map(type => type.name));
-        const sourceCode = context.getSourceCode();
-        return {
-            'ObjectTypeDefinition,ObjectTypeExtension'(node) {
-                if (!rootTypeNames.has(node.name.value))
-                    return;
-                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;
-                    const type = schema.getType(name);
-                    const resultType = (type === null || type === void 0 ? void 0 : type.astNode) ? getNodeName(type.astNode) : type === null || type === void 0 ? void 0 : 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('!', ''));
-                                },
-                            },
-                        ],
-                    });
-                }
-            },
-        };
+    messages: {
+      [RULE_ID]: "Unexpected non-null result {{ resultType }} in {{ rootType }}"
     },
+    schema: []
+  },
+  create(context) {
+    const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const rootTypeNames = new Set(
+      [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()].filter(truthy).map((type) => type.name)
+    );
+    const sourceCode = context.getSourceCode();
+    return {
+      "ObjectTypeDefinition,ObjectTypeExtension"(node) {
+        if (!rootTypeNames.has(node.name.value))
+          return;
+        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;
+          const type = schema.getType(name);
+          const 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-type-pattern-with-oneof.d.mts

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

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

@@ -1,16 +1,18 @@
-import { displayNodeName } from '../utils.js';
-const RULE_ID = 'require-type-pattern-with-oneof';
-export const 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 */ `
+import { displayNodeName } from "../utils.js";
+const RULE_ID = "require-type-pattern-with-oneof";
+const 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!
             }
@@ -27,33 +29,38 @@ export const rule = {
             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, }) {
-                var _a;
-                const requiredFields = ['error', 'ok'];
-                for (const fieldName of requiredFields) {
-                    if (!((_a = parent.fields) === null || _a === void 0 ? void 0 : _a.some(field => field.name.value === fieldName))) {
-                        context.report({
-                            node: parent.name,
-                            messageId: RULE_ID,
-                            data: {
-                                nodeName: displayNodeName(parent),
-                                fieldName,
-                            },
-                        });
-                    }
-                }
-            },
-        };
+    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) {
+          if (!parent.fields?.some((field) => field.name.value === fieldName)) {
+            context.report({
+              node: parent.name,
+              messageId: RULE_ID,
+              data: {
+                nodeName: displayNodeName(parent),
+                fieldName
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+export {
+  rule
 };

package/{typings/rules/selection-set-depth.d.cts → esm/rules/selection-set-depth.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 minItems: 1;
@@ -23,6 +30,7 @@ declare const schema: {
         };
     };
 };
-export type RuleOptions = FromSchema<typeof schema>;
-export declare const rule: GraphQLESLintRule<RuleOptions>;
-export {};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

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

@@ -1,37 +1,37 @@
-import { Kind } from 'graphql';
-import depthLimit from 'graphql-depth-limit';
-import { ARRAY_DEFAULT_OPTIONS, logger, requireSiblingsOperations } from '../utils.js';
-const RULE_ID = 'selection-set-depth';
+import { Kind } from "graphql";
+import depthLimit from "graphql-depth-limit";
+import { ARRAY_DEFAULT_OPTIONS, logger, requireSiblingsOperations } from "../utils.js";
+const RULE_ID = "selection-set-depth";
 const schema = {
-    type: 'array',
-    minItems: 1,
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['maxDepth'],
-        properties: {
-            maxDepth: {
-                type: 'number',
-            },
-            ignore: ARRAY_DEFAULT_OPTIONS,
-        },
-    },
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["maxDepth"],
+    properties: {
+      maxDepth: {
+        type: "number"
+      },
+      ignore: ARRAY_DEFAULT_OPTIONS
+    }
+  }
 };
-export const rule = {
-    meta: {
-        type: 'suggestion',
-        hasSuggestions: true,
-        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: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    usage: [{ maxDepth: 1 }],
-                    code: `
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    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: true,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ maxDepth: 1 }],
+          code: `
             query deep2 {
               viewer { # Level 0
                 albums { # Level 1
@@ -39,12 +39,12 @@ export const rule = {
                 }
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    usage: [{ maxDepth: 4 }],
-                    code: `
+          `
+        },
+        {
+          title: "Correct",
+          usage: [{ maxDepth: 4 }],
+          code: `
             query deep2 {
               viewer { # Level 0
                 albums { # Level 1
@@ -52,12 +52,12 @@ export const rule = {
                 }
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct (ignored field)',
-                    usage: [{ maxDepth: 1, ignore: ['albums'] }],
-                    code: `
+          `
+        },
+        {
+          title: "Correct (ignored field)",
+          usage: [{ maxDepth: 1, ignore: ["albums"] }],
+          code: `
             query deep2 {
               viewer { # Level 0
                 albums { # Level 1
@@ -65,67 +65,77 @@ export const rule = {
                 }
               }
             }
-          `,
-                },
-            ],
-            recommended: true,
-            configOptions: [{ maxDepth: 7 }],
-        },
-        schema,
+          `
+        }
+      ],
+      recommended: true,
+      configOptions: [{ maxDepth: 7 }]
     },
-    create(context) {
-        let siblings = null;
+    schema
+  },
+  create(context) {
+    let siblings = null;
+    try {
+      siblings = requireSiblingsOperations(RULE_ID, context);
+    } catch {
+      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];
+    const checkFn = depthLimit(maxDepth, { ignore });
+    return {
+      "OperationDefinition, FragmentDefinition"(node) {
         try {
-            siblings = requireSiblingsOperations(RULE_ID, context);
-        }
-        catch (_a) {
-            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];
-        const checkFn = depthLimit(maxDepth, { ignore });
-        return {
-            'OperationDefinition, FragmentDefinition'(node) {
-                try {
-                    const rawNode = node.rawNode();
-                    const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
-                    const document = {
-                        kind: Kind.DOCUMENT,
-                        definitions: [rawNode, ...fragmentsInUse],
-                    };
-                    checkFn({
-                        getDocument: () => document,
-                        reportError(error) {
-                            const { line, column } = error.locations[0];
-                            const ancestors = context.getAncestors();
-                            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.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 sourceCode = context.getSourceCode();
-                                                const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
-                                                const parentNode = foundNode.parent.parent;
-                                                return fixer.remove(foundNode.kind === 'Name' ? parentNode.parent : parentNode);
-                                            },
-                                        },
-                                    ],
-                                }),
-                            });
-                        },
-                    });
-                }
-                catch (e) {
-                    logger.warn(`Rule "${RULE_ID}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`, e);
+          const rawNode = node.rawNode();
+          const fragmentsInUse = siblings ? siblings.getFragmentsInUse(rawNode) : [];
+          const document = {
+            kind: Kind.DOCUMENT,
+            definitions: [rawNode, ...fragmentsInUse]
+          };
+          checkFn({
+            getDocument: () => document,
+            reportError(error) {
+              const { line, column } = error.locations[0];
+              const ancestors = context.getAncestors();
+              const token = ancestors[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 sourceCode = context.getSourceCode();
+                        const foundNode = sourceCode.getNodeByRangeIndex(token.range[0]);
+                        const parentNode = foundNode.parent.parent;
+                        return fixer.remove(
+                          foundNode.kind === "Name" ? parentNode.parent : parentNode
+                        );
+                      }
+                    }
+                  ]
                 }
-            },
-        };
-    },
+              });
+            }
+          });
+        } catch (e) {
+          logger.warn(
+            `Rule "${RULE_ID}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`,
+            e
+          );
+        }
+      }
+    };
+  }
+};
+export {
+  rule
 };