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

package/cjs/rules/no-unreachable-types.js

@@ -1,110 +1,137 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const tslib_1 = require("tslib");
-const graphql_1 = require("graphql");
-const lodash_lowercase_1 = tslib_1.__importDefault(require("lodash.lowercase"));
-const utils_js_1 = require("../utils.js");
-const RULE_ID = 'no-unreachable-types';
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var no_unreachable_types_exports = {};
+__export(no_unreachable_types_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_unreachable_types_exports);
+var import_graphql = require("graphql");
+var import_lodash = __toESM(require("lodash.lowercase"));
+var import_utils = require("../utils.js");
+const RULE_ID = "no-unreachable-types";
 const KINDS = [
-    graphql_1.Kind.DIRECTIVE_DEFINITION,
-    graphql_1.Kind.OBJECT_TYPE_DEFINITION,
-    graphql_1.Kind.OBJECT_TYPE_EXTENSION,
-    graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
-    graphql_1.Kind.INTERFACE_TYPE_EXTENSION,
-    graphql_1.Kind.SCALAR_TYPE_DEFINITION,
-    graphql_1.Kind.SCALAR_TYPE_EXTENSION,
-    graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
-    graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION,
-    graphql_1.Kind.UNION_TYPE_DEFINITION,
-    graphql_1.Kind.UNION_TYPE_EXTENSION,
-    graphql_1.Kind.ENUM_TYPE_DEFINITION,
-    graphql_1.Kind.ENUM_TYPE_EXTENSION,
+  import_graphql.Kind.DIRECTIVE_DEFINITION,
+  import_graphql.Kind.OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.OBJECT_TYPE_EXTENSION,
+  import_graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  import_graphql.Kind.INTERFACE_TYPE_EXTENSION,
+  import_graphql.Kind.SCALAR_TYPE_DEFINITION,
+  import_graphql.Kind.SCALAR_TYPE_EXTENSION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+  import_graphql.Kind.UNION_TYPE_DEFINITION,
+  import_graphql.Kind.UNION_TYPE_EXTENSION,
+  import_graphql.Kind.ENUM_TYPE_DEFINITION,
+  import_graphql.Kind.ENUM_TYPE_EXTENSION
 ];
 let reachableTypesCache;
-const RequestDirectiveLocations = new Set([
-    graphql_1.DirectiveLocation.QUERY,
-    graphql_1.DirectiveLocation.MUTATION,
-    graphql_1.DirectiveLocation.SUBSCRIPTION,
-    graphql_1.DirectiveLocation.FIELD,
-    graphql_1.DirectiveLocation.FRAGMENT_DEFINITION,
-    graphql_1.DirectiveLocation.FRAGMENT_SPREAD,
-    graphql_1.DirectiveLocation.INLINE_FRAGMENT,
-    graphql_1.DirectiveLocation.VARIABLE_DEFINITION,
+const RequestDirectiveLocations = /* @__PURE__ */ new Set([
+  import_graphql.DirectiveLocation.QUERY,
+  import_graphql.DirectiveLocation.MUTATION,
+  import_graphql.DirectiveLocation.SUBSCRIPTION,
+  import_graphql.DirectiveLocation.FIELD,
+  import_graphql.DirectiveLocation.FRAGMENT_DEFINITION,
+  import_graphql.DirectiveLocation.FRAGMENT_SPREAD,
+  import_graphql.DirectiveLocation.INLINE_FRAGMENT,
+  import_graphql.DirectiveLocation.VARIABLE_DEFINITION
 ]);
 function getReachableTypes(schema) {
-    // We don't want cache reachableTypes on test environment
-    // Otherwise reachableTypes will be same for all tests
-    if (process.env.NODE_ENV !== 'test' && reachableTypesCache) {
-        return reachableTypesCache;
+  if (process.env.NODE_ENV !== "test" && reachableTypesCache) {
+    return reachableTypesCache;
+  }
+  const reachableTypes = /* @__PURE__ */ new Set();
+  const collect = (node) => {
+    const typeName = (0, import_utils.getTypeName)(node);
+    if (reachableTypes.has(typeName)) {
+      return;
     }
-    const reachableTypes = new Set();
-    const collect = (node) => {
-        const typeName = (0, utils_js_1.getTypeName)(node);
-        if (reachableTypes.has(typeName)) {
-            return;
-        }
-        reachableTypes.add(typeName);
-        const type = schema.getType(typeName) || schema.getDirective(typeName);
-        if ((0, graphql_1.isInterfaceType)(type)) {
-            const { objects, interfaces } = schema.getImplementations(type);
-            for (const { astNode } of [...objects, ...interfaces]) {
-                (0, graphql_1.visit)(astNode, visitor);
-            }
-        }
-        else if (type === null || type === void 0 ? void 0 : type.astNode) {
-            // astNode can be undefined for ID, String, Boolean
-            (0, graphql_1.visit)(type.astNode, visitor);
-        }
-    };
-    const visitor = {
-        InterfaceTypeDefinition: collect,
-        ObjectTypeDefinition: collect,
-        InputValueDefinition: collect,
-        UnionTypeDefinition: collect,
-        FieldDefinition: collect,
-        Directive: collect,
-        NamedType: collect,
-    };
-    for (const type of [
-        schema,
-        schema.getQueryType(),
-        schema.getMutationType(),
-        schema.getSubscriptionType(),
-    ]) {
-        // if schema don't have Query type, schema.astNode will be undefined
-        if (type === null || type === void 0 ? void 0 : type.astNode) {
-            (0, graphql_1.visit)(type.astNode, visitor);
-        }
+    reachableTypes.add(typeName);
+    const type = schema.getType(typeName) || schema.getDirective(typeName);
+    if ((0, import_graphql.isInterfaceType)(type)) {
+      const { objects, interfaces } = schema.getImplementations(type);
+      for (const { astNode } of [...objects, ...interfaces]) {
+        (0, import_graphql.visit)(astNode, visitor);
+      }
+    } else if (type?.astNode) {
+      (0, import_graphql.visit)(type.astNode, visitor);
     }
-    for (const node of schema.getDirectives()) {
-        if (node.locations.some(location => RequestDirectiveLocations.has(location))) {
-            reachableTypes.add(node.name);
-            for (const arg of node.args) {
-                const argTypeName = 'name' in arg.type && arg.type.name;
-                if (argTypeName) {
-                    reachableTypes.add(argTypeName);
-                }
-            }
+  };
+  const visitor = {
+    InterfaceTypeDefinition: collect,
+    ObjectTypeDefinition: collect,
+    InputValueDefinition: collect,
+    UnionTypeDefinition: collect,
+    FieldDefinition: collect,
+    Directive: collect,
+    NamedType: collect
+  };
+  for (const type of [
+    schema,
+    // visiting SchemaDefinition node
+    schema.getQueryType(),
+    schema.getMutationType(),
+    schema.getSubscriptionType()
+  ]) {
+    if (type?.astNode) {
+      (0, import_graphql.visit)(type.astNode, visitor);
+    }
+  }
+  for (const node of schema.getDirectives()) {
+    if (node.locations.some((location) => RequestDirectiveLocations.has(location))) {
+      reachableTypes.add(node.name);
+      for (const arg of node.args) {
+        const argTypeName = "name" in arg.type && arg.type.name;
+        if (argTypeName) {
+          reachableTypes.add(argTypeName);
         }
+      }
     }
-    reachableTypesCache = reachableTypes;
-    return reachableTypesCache;
+  }
+  reachableTypesCache = reachableTypes;
+  return reachableTypesCache;
 }
-exports.rule = {
-    meta: {
-        messages: {
-            [RULE_ID]: '{{ type }} `{{ typeName }}` is unreachable.',
-        },
-        docs: {
-            description: 'Requires all types to be reachable at some level by root level fields.',
-            category: 'Schema',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSchema: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    messages: {
+      [RULE_ID]: "{{ type }} `{{ typeName }}` is unreachable."
+    },
+    docs: {
+      description: "Requires all types to be reachable at some level by root level fields.",
+      category: "Schema",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             type User {
               id: ID!
               name: String
@@ -113,11 +140,14 @@ exports.rule = {
             type Query {
               me: String
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             type User {
               id: ID!
               name: String
@@ -126,39 +156,44 @@ exports.rule = {
             type Query {
               me: User
             }
-          `,
-                },
-            ],
-            recommended: true,
-        },
-        type: 'suggestion',
-        schema: [],
-        hasSuggestions: true,
+          `
+          )
+        }
+      ],
+      recommended: true
     },
-    create(context) {
-        const schema = (0, utils_js_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
-        const reachableTypes = getReachableTypes(schema);
-        return {
-            [`:matches(${KINDS}) > .name`](node) {
-                const typeName = node.value;
-                if (!reachableTypes.has(typeName)) {
-                    const type = (0, lodash_lowercase_1.default)(node.parent.kind.replace(/(Extension|Definition)$/, ''));
-                    context.report({
-                        node,
-                        messageId: RULE_ID,
-                        data: {
-                            type: type[0].toUpperCase() + type.slice(1),
-                            typeName,
-                        },
-                        suggest: [
-                            {
-                                desc: `Remove \`${typeName}\``,
-                                fix: fixer => fixer.remove(node.parent),
-                            },
-                        ],
-                    });
-                }
+    type: "suggestion",
+    schema: [],
+    hasSuggestions: true
+  },
+  create(context) {
+    const schema = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    const reachableTypes = getReachableTypes(schema);
+    return {
+      [`:matches(${KINDS}) > .name`](node) {
+        const typeName = node.value;
+        if (!reachableTypes.has(typeName)) {
+          const type = (0, import_lodash.default)(node.parent.kind.replace(/(Extension|Definition)$/, ""));
+          context.report({
+            node,
+            messageId: RULE_ID,
+            data: {
+              type: type[0].toUpperCase() + type.slice(1),
+              typeName
             },
-        };
-    },
+            suggest: [
+              {
+                desc: `Remove \`${typeName}\``,
+                fix: (fixer) => fixer.remove(node.parent)
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/no-unused-fields.d.ts

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

package/cjs/rules/no-unused-fields.js

@@ -1,55 +1,73 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rule = void 0;
-const graphql_1 = require("graphql");
-const utils_js_1 = require("../utils.js");
-const RULE_ID = 'no-unused-fields';
+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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var no_unused_fields_exports = {};
+__export(no_unused_fields_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_unused_fields_exports);
+var import_graphql = require("graphql");
+var import_utils = require("../utils.js");
+const RULE_ID = "no-unused-fields";
 let usedFieldsCache;
 function getUsedFields(schema, operations) {
-    // We don't want cache usedFields on test environment
-    // Otherwise usedFields will be same for all tests
-    if (process.env.NODE_ENV !== 'test' && usedFieldsCache) {
-        return usedFieldsCache;
-    }
-    const usedFields = Object.create(null);
-    const typeInfo = new graphql_1.TypeInfo(schema);
-    const visitor = (0, graphql_1.visitWithTypeInfo)(typeInfo, {
-        Field(node) {
-            var _a;
-            const fieldDef = typeInfo.getFieldDef();
-            if (!fieldDef) {
-                // skip visiting this node if field is not defined in schema
-                return false;
-            }
-            const parentTypeName = typeInfo.getParentType().name;
-            const fieldName = node.name.value;
-            (_a = usedFields[parentTypeName]) !== null && _a !== void 0 ? _a : (usedFields[parentTypeName] = new Set());
-            usedFields[parentTypeName].add(fieldName);
-        },
-    });
-    const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
-    for (const { document } of allDocuments) {
-        (0, graphql_1.visit)(document, visitor);
-    }
-    usedFieldsCache = usedFields;
+  if (process.env.NODE_ENV !== "test" && usedFieldsCache) {
     return usedFieldsCache;
+  }
+  const usedFields = /* @__PURE__ */ Object.create(null);
+  const typeInfo = new import_graphql.TypeInfo(schema);
+  const visitor = (0, import_graphql.visitWithTypeInfo)(typeInfo, {
+    Field(node) {
+      const fieldDef = typeInfo.getFieldDef();
+      if (!fieldDef) {
+        return false;
+      }
+      const parentTypeName = typeInfo.getParentType().name;
+      const fieldName = node.name.value;
+      usedFields[parentTypeName] ??= /* @__PURE__ */ new Set();
+      usedFields[parentTypeName].add(fieldName);
+    }
+  });
+  const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+  for (const { document } of allDocuments) {
+    (0, import_graphql.visit)(document, visitor);
+  }
+  usedFieldsCache = usedFields;
+  return usedFieldsCache;
 }
-exports.rule = {
-    meta: {
-        messages: {
-            [RULE_ID]: 'Field "{{fieldName}}" is unused',
-        },
-        docs: {
-            description: 'Requires all fields to be used at some level by siblings operations.',
-            category: 'Schema',
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            requiresSiblings: true,
-            requiresSchema: true,
-            isDisabledForAllConfig: true,
-            examples: [
-                {
-                    title: 'Incorrect',
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    messages: {
+      [RULE_ID]: 'Field "{{fieldName}}" is unused'
+    },
+    docs: {
+      description: "Requires all fields to be used at some level by siblings operations.",
+      category: "Schema",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: true,
+      requiresSchema: true,
+      isDisabledForAllConfig: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
             type User {
               id: ID!
               name: String
@@ -66,11 +84,14 @@ exports.rule = {
                 name
               }
             }
-          `,
-                },
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             type User {
               id: ID!
               name: String
@@ -86,45 +107,49 @@ exports.rule = {
                 name
               }
             }
-          `,
-                },
-            ],
-        },
-        type: 'suggestion',
-        schema: [],
-        hasSuggestions: true,
-    },
-    create(context) {
-        const schema = (0, utils_js_1.requireGraphQLSchemaFromContext)(RULE_ID, context);
-        const siblingsOperations = (0, utils_js_1.requireSiblingsOperations)(RULE_ID, context);
-        const usedFields = getUsedFields(schema, siblingsOperations);
-        return {
-            FieldDefinition(node) {
-                var _a;
-                const fieldName = node.name.value;
-                const parentTypeName = node.parent.name.value;
-                const isUsed = (_a = usedFields[parentTypeName]) === null || _a === void 0 ? void 0 : _a.has(fieldName);
-                if (isUsed) {
-                    return;
-                }
-                context.report({
-                    node: node.name,
-                    messageId: RULE_ID,
-                    data: { fieldName },
-                    suggest: [
-                        {
-                            desc: `Remove \`${fieldName}\` field`,
-                            fix(fixer) {
-                                const sourceCode = context.getSourceCode();
-                                const tokenBefore = sourceCode.getTokenBefore(node);
-                                const tokenAfter = sourceCode.getTokenAfter(node);
-                                const isEmptyType = tokenBefore.type === '{' && tokenAfter.type === '}';
-                                return fixer.remove((isEmptyType ? node.parent : node));
-                            },
-                        },
-                    ],
-                });
-            },
-        };
+          `
+          )
+        }
+      ]
     },
+    type: "suggestion",
+    schema: [],
+    hasSuggestions: true
+  },
+  create(context) {
+    const schema = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    const siblingsOperations = (0, import_utils.requireSiblingsOperations)(RULE_ID, context);
+    const usedFields = getUsedFields(schema, siblingsOperations);
+    return {
+      FieldDefinition(node) {
+        const fieldName = node.name.value;
+        const parentTypeName = node.parent.name.value;
+        const isUsed = usedFields[parentTypeName]?.has(fieldName);
+        if (isUsed) {
+          return;
+        }
+        context.report({
+          node: node.name,
+          messageId: RULE_ID,
+          data: { fieldName },
+          suggest: [
+            {
+              desc: `Remove \`${fieldName}\` field`,
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+                const tokenBefore = sourceCode.getTokenBefore(node);
+                const tokenAfter = sourceCode.getTokenAfter(node);
+                const isEmptyType = tokenBefore.type === "{" && tokenAfter.type === "}";
+                return fixer.remove(isEmptyType ? node.parent : node);
+              }
+            }
+          ]
+        });
+      }
+    };
+  }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/{typings → cjs}/rules/relay-arguments.d.ts

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.js';
+import { i as GraphQLESLintRule } from '../types-e3367e3c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.js';
+
 declare const schema: {
     readonly type: "array";
     readonly maxItems: 1;
@@ -16,6 +23,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 };