@graphql-eslint/eslint-plugin 3.14.3-alpha-20221228000849-7bb2626 → 3.14.4-alpha-20221229151835-f439b5b

package/esm/documents.js

@@ -9,7 +9,7 @@ const handleVirtualPath = (documents) => {
     const filepathMap = Object.create(null);
     return documents.map(source => {
         var _a;
-        const { location } = source;
+        const location = source.location;
         if (['.gql', '.graphql'].some(extension => location.endsWith(extension))) {
             return source;
         }
@@ -70,15 +70,17 @@ export function getDocuments(project) {
     // Since the siblings array is cached, we can use it as cache key.
     // We should get the same array reference each time we get
     // to this point for the same graphql project
-    if (siblingOperationsCache.has(siblings)) {
-        return siblingOperationsCache.get(siblings);
+    const value = siblingOperationsCache.get(siblings);
+    if (value) {
+        return value;
     }
     let fragmentsCache = null;
     const getFragments = () => {
+        var _a;
         if (fragmentsCache === null) {
             const result = [];
             for (const source of siblings) {
-                for (const definition of source.document.definitions) {
+                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
                     if (definition.kind === Kind.FRAGMENT_DEFINITION) {
                         result.push({
                             filePath: source.location,
@@ -93,10 +95,11 @@ export function getDocuments(project) {
     };
     let cachedOperations = null;
     const getOperations = () => {
+        var _a;
         if (cachedOperations === null) {
             const result = [];
             for (const source of siblings) {
-                for (const definition of source.document.definitions) {
+                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
                     if (definition.kind === Kind.OPERATION_DEFINITION) {
                         result.push({
                             filePath: source.location,

package/esm/estree-converter/converter.js

@@ -1,7 +1,7 @@
 import { TypeInfo, visit, visitWithTypeInfo, Kind, } from 'graphql';
 import { convertLocation } from './utils.js';
 export function convertToESTree(node, schema) {
-    const typeInfo = schema ? new TypeInfo(schema) : null;
+    const typeInfo = schema && new TypeInfo(schema);
     const visitor = {
         leave(node, key, parent) {
             const leadingComments = 'description' in node && node.description

package/esm/graphql-config.js

@@ -1,6 +1,6 @@
 import { dirname } from 'path';
 import debugFactory from 'debug';
-import { GraphQLConfig, loadConfigSync } from 'graphql-config';
+import { GraphQLConfig, loadConfigSync, } from 'graphql-config';
 import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 const debug = debugFactory('graphql-eslint:graphql-config');
 let graphQLConfig;

package/esm/parser.js

@@ -21,7 +21,7 @@ export function parseForESLint(code, options) {
         const realFilepath = filePath.replace(VIRTUAL_DOCUMENT_REGEX, '');
         const project = gqlConfig.getProjectForFile(realFilepath);
         const schema = getSchema(project, options.schemaOptions);
-        const rootTree = convertToESTree(document, schema instanceof GraphQLSchema ? schema : null);
+        const rootTree = convertToESTree(document, schema instanceof GraphQLSchema ? schema : undefined);
         return {
             services: {
                 schema,
@@ -39,7 +39,9 @@ export function parseForESLint(code, options) {
         };
     }
     catch (error) {
-        error.message = `[graphql-eslint] ${error.message}`;
+        if (error instanceof Error) {
+            error.message = `[graphql-eslint] ${error.message}`;
+        }
         // In case of GraphQL parser error, we report it to ESLint as a parser error that matches the requirements
         // of ESLint. This will make sure to display it correctly in IDEs and lint results.
         if (error instanceof GraphQLError) {

package/esm/processor.js

@@ -2,7 +2,7 @@ import { relative } from 'path';
 import { gqlPluckFromCodeStringSync, } from '@graphql-tools/graphql-tag-pluck';
 import { asArray } from '@graphql-tools/utils';
 import { loadOnDiskGraphQLConfig } from './graphql-config.js';
-import { CWD, REPORT_ON_FIRST_CHARACTER } from './utils.js';
+import { CWD, REPORT_ON_FIRST_CHARACTER, truthy } from './utils.js';
 const blocksMap = new Map();
 let onDiskConfig;
 let onDiskConfigLoaded = false;
@@ -23,7 +23,7 @@ export const processor = {
                     ...modules.map(({ identifier }) => identifier),
                     ...asArray(globalGqlIdentifierName),
                     gqlMagicComment,
-                ].filter(Boolean)),
+                ].filter(truthy)),
             ];
         }
         if (keywords.every(keyword => !code.includes(keyword))) {
@@ -45,7 +45,9 @@ export const processor = {
             return [...blocks, code /* source code must be provided and be last */];
         }
         catch (error) {
-            error.message = `[graphql-eslint] Error while preprocessing "${relative(CWD, filePath)}" file\n\n${error.message}`;
+            if (error instanceof Error) {
+                error.message = `[graphql-eslint] Error while preprocessing "${relative(CWD, filePath)}" file\n\n${error.message}`;
+            }
             // eslint-disable-next-line no-console
             console.error(error);
             // in case of parsing error return code as is

package/esm/rules/alphabetize.js

@@ -1,6 +1,6 @@
 import { Kind, } from 'graphql';
 import lowerCase from 'lodash.lowercase';
-import { ARRAY_DEFAULT_OPTIONS } from '../utils.js';
+import { ARRAY_DEFAULT_OPTIONS, truthy } from '../utils.js';
 const RULE_ID = 'alphabetize';
 const fieldsEnum = [
     Kind.OBJECT_TYPE_DEFINITION,
@@ -224,7 +224,7 @@ export const rule = {
                 : node;
             return [from.range[0], to.range[1]];
         }
-        function checkNodes(nodes) {
+        function checkNodes(nodes = []) {
             var _a, _b, _c, _d;
             // Starts from 1, ignore nodes.length <= 1
             for (let i = 1; i < nodes.length; i += 1) {
@@ -269,6 +269,7 @@ export const rule = {
                     }
                 }
                 context.report({
+                    // @ts-expect-error can't be undefined
                     node: ('alias' in currNode && currNode.alias) || currNode.name,
                     messageId: RULE_ID,
                     data: {
@@ -301,7 +302,7 @@ export const rule = {
                 Kind.INPUT_OBJECT_TYPE_EXTENSION,
             ],
         ]
-            .filter(Boolean)
+            .filter(truthy)
             .flat();
         const fieldsSelector = kinds.join(',');
         const hasEnumValues = ((_b = opts.values) === null || _b === void 0 ? void 0 : _b[0]) === Kind.ENUM_TYPE_DEFINITION;
@@ -326,7 +327,8 @@ export const rule = {
         }
         if (hasVariables) {
             listeners.OperationDefinition = (node) => {
-                checkNodes(node.variableDefinitions.map(varDef => varDef.variable));
+                var _a;
+                checkNodes((_a = node.variableDefinitions) === null || _a === void 0 ? void 0 : _a.map(varDef => varDef.variable));
             };
         }
         if (argumentsSelector) {

package/esm/rules/graphql-js-validation.js

@@ -45,10 +45,10 @@ function validateDocument({ context, schema = null, documentNode, rule, hasDidYo
             });
         }
     }
-    catch (e) {
+    catch (error) {
         context.report({
             loc: REPORT_ON_FIRST_CHARACTER,
-            message: e.message,
+            message: error.message,
         });
     }
 }
@@ -185,10 +185,13 @@ export const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule({
         if (ignoreClientDirectives.length === 0) {
             return documentNode;
         }
-        const filterDirectives = (node) => ({
-            ...node,
-            directives: node.directives.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
-        });
+        const filterDirectives = (node) => {
+            var _a;
+            return ({
+                ...node,
+                directives: (_a = node.directives) === null || _a === void 0 ? void 0 : _a.filter(directive => !ignoreClientDirectives.includes(directive.name.value)),
+            });
+        };
         return visit(documentNode, {
             Field: filterDirectives,
             OperationDefinition: filterDirectives,

package/esm/rules/input-name.js

@@ -76,12 +76,12 @@ export const rule = {
         const options = {
             checkInputType: false,
             caseSensitiveInputType: true,
-            checkQueries: false,
             checkMutations: true,
             ...context.options[0],
         };
-        const shouldCheckType = node => (options.checkMutations && isMutationType(node)) ||
-            (options.checkQueries && isQueryType(node));
+        const shouldCheckType = (node) => (options.checkMutations && isMutationType(node)) ||
+            (options.checkQueries && isQueryType(node)) ||
+            false;
         const listeners = {
             'FieldDefinition > InputValueDefinition[name.value!=input] > Name'(node) {
                 if (shouldCheckType(node.parent.parent.parent)) {
@@ -101,9 +101,10 @@ export const rule = {
         };
         if (options.checkInputType) {
             listeners['FieldDefinition > InputValueDefinition NamedType'] = (node) => {
-                const findInputType = item => {
+                const findInputType = (item) => {
                     let currentNode = item;
                     while (currentNode.type !== Kind.INPUT_VALUE_DEFINITION) {
+                        // @ts-expect-error TODO try fix type error
                         currentNode = currentNode.parent;
                     }
                     return currentNode;

package/esm/rules/naming-convention.js

@@ -1,5 +1,5 @@
 import { Kind } from 'graphql';
-import { TYPES_KINDS, convertCase, ARRAY_DEFAULT_OPTIONS } from '../utils.js';
+import { TYPES_KINDS, convertCase, ARRAY_DEFAULT_OPTIONS, truthy } from '../utils.js';
 const KindToDisplayName = {
     // types
     [Kind.OBJECT_TYPE_DEFINITION]: 'Type',
@@ -212,7 +212,7 @@ export const rule = {
         const options = context.options[0] || {};
         const { allowLeadingUnderscore, allowTrailingUnderscore, types, ...restOptions } = options;
         function normalisePropertyOption(kind) {
-            const style = restOptions[kind] || types;
+            const style = (restOptions[kind] || types);
             return typeof style === 'object' ? style : { style };
         }
         function report(node, message, suggestedName) {
@@ -298,7 +298,7 @@ export const rule = {
         if (!allowTrailingUnderscore) {
             listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore(false);
         }
-        const selectors = new Set([types && TYPES_KINDS, Object.keys(restOptions)].flat().filter(Boolean));
+        const selectors = new Set([types && TYPES_KINDS, Object.keys(restOptions)].flat().filter(truthy));
         for (const selector of selectors) {
             listeners[selector] = checkNode(selector);
         }

package/esm/rules/no-case-insensitive-enum-values-duplicates.js

@@ -37,9 +37,10 @@ export const rule = {
         const selector = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION].join(',');
         return {
             [selector](node) {
-                const duplicates = node.values.filter((item, index, array) => array.findIndex(v => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !==
+                var _a;
+                const duplicates = (_a = node.values) === null || _a === void 0 ? void 0 : _a.filter((item, index, array) => array.findIndex(v => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !==
                     index);
-                for (const duplicate of duplicates) {
+                for (const duplicate of duplicates || []) {
                     const enumName = duplicate.name.value;
                     context.report({
                         node: duplicate.name,

package/esm/rules/no-duplicate-fields.js

@@ -86,13 +86,13 @@ export const rule = {
         return {
             OperationDefinition(node) {
                 const set = new Set();
-                for (const varDef of node.variableDefinitions) {
+                for (const varDef of node.variableDefinitions || []) {
                     checkNode(set, varDef.variable.name);
                 }
             },
             Field(node) {
                 const set = new Set();
-                for (const arg of node.arguments) {
+                for (const arg of node.arguments || []) {
                     checkNode(set, arg.name);
                 }
             },

package/esm/rules/no-hashtag-description.js

@@ -78,6 +78,9 @@ export const rule = {
                             });
                         }
                     }
+                    if (!next) {
+                        break;
+                    }
                     token = next;
                 }
             },

package/esm/rules/no-root-type.js

@@ -1,4 +1,4 @@
-import { ARRAY_DEFAULT_OPTIONS, requireGraphQLSchemaFromContext } from '../utils.js';
+import { ARRAY_DEFAULT_OPTIONS, requireGraphQLSchemaFromContext, truthy } from '../utils.js';
 const schema = {
     type: 'array',
     minItems: 1,
@@ -57,7 +57,7 @@ export const rule = {
             disallow.has('mutation') && schema.getMutationType(),
             disallow.has('subscription') && schema.getSubscriptionType(),
         ]
-            .filter(Boolean)
+            .filter(truthy)
             .map(type => type.name)
             .join('|');
         if (!rootTypeNames) {

package/esm/rules/no-typename-prefix.js

@@ -37,7 +37,7 @@ export const rule = {
             'ObjectTypeDefinition, ObjectTypeExtension, InterfaceTypeDefinition, InterfaceTypeExtension'(node) {
                 const typeName = node.name.value;
                 const lowerTypeName = typeName.toLowerCase();
-                for (const field of node.fields) {
+                for (const field of node.fields || []) {
                     const fieldName = field.name.value;
                     if (fieldName.toLowerCase().startsWith(lowerTypeName)) {
                         context.report({

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

@@ -48,7 +48,7 @@ function getReachableTypes(schema) {
                 visit(astNode, visitor);
             }
         }
-        else if (type.astNode) {
+        else if (type === null || type === void 0 ? void 0 : type.astNode) {
             // astNode can be undefined for ID, String, Boolean
             visit(type.astNode, visitor);
         }

package/esm/rules/relay-arguments.js

@@ -69,11 +69,12 @@ export const rule = {
         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(fieldNode.arguments.map(argument => [argument.name.value, argument]));
+                const args = Object.fromEntries(((_a = fieldNode.arguments) === null || _a === void 0 ? void 0 : _a.map(argument => [argument.name.value, argument])) || []);
                 const hasForwardPagination = Boolean(args.first && args.after);
                 const hasBackwardPagination = Boolean(args.last && args.before);
                 if (!hasForwardPagination && !hasBackwardPagination) {

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

@@ -17,8 +17,8 @@ export const NON_OBJECT_TYPES = [
     Kind.INTERFACE_TYPE_EXTENSION,
 ];
 const notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`;
-const hasEdgesField = (node) => node.fields.some(field => field.name.value === 'edges');
-const hasPageInfoField = (node) => node.fields.some(field => field.name.value === 'pageInfo');
+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',

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

@@ -16,12 +16,13 @@ function getEdgeTypes(schema) {
     const edgeTypes = new Set();
     const visitor = {
         ObjectTypeDefinition(node) {
+            var _a;
             const typeName = node.name.value;
             const hasConnectionSuffix = typeName.endsWith('Connection');
             if (!hasConnectionSuffix) {
                 return;
             }
-            const edges = node.fields.find(field => field.name.value === 'edges');
+            const edges = (_a = node.fields) === null || _a === void 0 ? void 0 : _a.find(field => field.name.value === 'edges');
             if (edges) {
                 const edgesTypeName = getTypeName(edges);
                 const edgesType = schema.getType(edgesTypeName);
@@ -113,7 +114,8 @@ export const rule = {
         const isNamedOrNonNullNamed = (node) => node.kind === Kind.NAMED_TYPE ||
             (node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.NAMED_TYPE);
         const checkNodeField = (node) => {
-            const nodeField = node.fields.find(field => field.name.value === 'node');
+            var _a, _b;
+            const nodeField = (_a = node.fields) === null || _a === void 0 ? void 0 : _a.find(field => field.name.value === 'node');
             const message = 'return either a Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types.';
             if (!nodeField) {
                 context.report({
@@ -130,14 +132,15 @@ export const rule = {
                 if (!isObjectType(type)) {
                     return;
                 }
-                const implementsNode = type.astNode.interfaces.some(n => n.name.value === 'Node');
+                const implementsNode = (_b = type.astNode.interfaces) === null || _b === void 0 ? void 0 : _b.some(n => n.name.value === 'Node');
                 if (!implementsNode) {
                     context.report({ node: node.name, messageId: MESSAGE_SHOULD_IMPLEMENTS_NODE });
                 }
             }
         };
         const checkCursorField = (node) => {
-            const cursorField = node.fields.find(field => field.name.value === 'cursor');
+            var _a;
+            const cursorField = (_a = node.fields) === null || _a === void 0 ? void 0 : _a.find(field => field.name.value === 'cursor');
             const message = 'return either a String, Scalar, or a non-null wrapper wrapper around one of those types.';
             if (!cursorField) {
                 context.report({

package/esm/rules/relay-page-info.js

@@ -58,7 +58,8 @@ export const rule = {
                 context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
             },
             'ObjectTypeDefinition[name.value=PageInfo]'(node) {
-                const fieldMap = Object.fromEntries(node.fields.map(field => [field.name.value, field]));
+                var _a;
+                const fieldMap = Object.fromEntries(((_a = node.fields) === null || _a === void 0 ? void 0 : _a.map(field => [field.name.value, field])) || []);
                 const checkField = (fieldName, typeName) => {
                     const field = fieldMap[fieldName];
                     let isAllowedType = false;

package/esm/rules/require-deprecation-date.js

@@ -68,9 +68,9 @@ export const rule = {
     create(context) {
         return {
             'Directive[name.value=deprecated]'(node) {
-                var _a;
+                var _a, _b;
                 const argName = ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.argumentName) || 'deletionDate';
-                const deletionDateNode = node.arguments.find(arg => arg.name.value === argName);
+                const deletionDateNode = (_b = node.arguments) === null || _b === void 0 ? void 0 : _b.find(arg => arg.name.value === argName);
                 if (!deletionDateNode) {
                     context.report({
                         node: node.name,

package/esm/rules/require-deprecation-reason.js

@@ -39,7 +39,8 @@ export const rule = {
     create(context) {
         return {
             'Directive[name.value=deprecated]'(node) {
-                const reasonArgument = node.arguments.find(arg => arg.name.value === 'reason');
+                var _a;
+                const reasonArgument = (_a = node.arguments) === null || _a === void 0 ? void 0 : _a.find(arg => arg.name.value === 'reason');
                 const value = reasonArgument && String(valueFromNode(reasonArgument.value)).trim();
                 if (!value) {
                     context.report({

package/esm/rules/require-description.js

@@ -164,7 +164,7 @@ export const rule = {
                 if (isOperation) {
                     const rawNode = node.rawNode();
                     const { prev, line } = rawNode.loc.startToken;
-                    if (prev.kind === TokenKind.COMMENT) {
+                    if ((prev === null || prev === void 0 ? void 0 : prev.kind) === TokenKind.COMMENT) {
                         const value = prev.value.trim();
                         const linesBefore = line - prev.line;
                         if (!value.startsWith('eslint') && linesBefore === 1) {

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

@@ -55,7 +55,7 @@ export const rule = {
                 const graphQLType = schema.getType(typeName);
                 if (isObjectType(graphQLType)) {
                     const { fields } = graphQLType.astNode;
-                    const hasQueryType = fields.some(field => getTypeName(field) === queryType.name);
+                    const hasQueryType = fields === null || fields === void 0 ? void 0 : fields.some(field => getTypeName(field) === queryType.name);
                     if (!hasQueryType) {
                         context.report({
                             node,

package/esm/rules/require-id-when-available.js

@@ -105,7 +105,8 @@ export const rule = {
                 }
                 const checkedFragmentSpreads = new Set();
                 const visitor = visitWithTypeInfo(typeInfo, {
-                    SelectionSet(node, key, parent) {
+                    SelectionSet(node, key, _parent) {
+                        const parent = _parent;
                         if (parent.kind === Kind.FRAGMENT_DEFINITION) {
                             checkedFragmentSpreads.add(parent.name.value);
                         }

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

@@ -35,7 +35,7 @@ export const rule = {
     },
     create(context) {
         return {
-            'Directive[name.value=oneOf]'({ parent, }) {
+            'Directive[name.value=oneOf]'({ parent }) {
                 const isTypeOrInput = [
                     Kind.OBJECT_TYPE_DEFINITION,
                     Kind.INPUT_OBJECT_TYPE_DEFINITION,
@@ -43,7 +43,7 @@ export const rule = {
                 if (!isTypeOrInput) {
                     return;
                 }
-                for (const field of parent.fields) {
+                for (const field of parent.fields || []) {
                     if (field.gqlType.kind === Kind.NON_NULL_TYPE) {
                         context.report({
                             node: field.name,

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

@@ -38,9 +38,10 @@ export const rule = {
     create(context) {
         return {
             'Directive[name.value=oneOf][parent.kind=ObjectTypeDefinition]'({ parent, }) {
+                var _a;
                 const requiredFields = ['error', 'ok'];
                 for (const fieldName of requiredFields) {
-                    if (!parent.fields.some(field => field.name.value === fieldName)) {
+                    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,

package/esm/rules/strict-id-in-types.js

@@ -1,5 +1,5 @@
 import { Kind } from 'graphql';
-import { ARRAY_DEFAULT_OPTIONS, requireGraphQLSchemaFromContext, englishJoinWords, } from '../utils.js';
+import { ARRAY_DEFAULT_OPTIONS, requireGraphQLSchemaFromContext, englishJoinWords, truthy, } from '../utils.js';
 const RULE_ID = 'strict-id-in-types';
 const schema = {
     type: 'array',
@@ -119,19 +119,19 @@ export const rule = {
             schema.getMutationType(),
             schema.getSubscriptionType(),
         ]
-            .filter(Boolean)
+            .filter(truthy)
             .map(type => type.name);
         const selector = `ObjectTypeDefinition[name.value!=/^(${rootTypeNames.join('|')})$/]`;
         return {
             [selector](node) {
-                var _a, _b;
+                var _a, _b, _c;
                 const typeName = node.name.value;
                 const shouldIgnoreNode = ((_a = options.exceptions.types) === null || _a === void 0 ? void 0 : _a.includes(typeName)) ||
                     ((_b = options.exceptions.suffixes) === null || _b === void 0 ? void 0 : _b.some(suffix => typeName.endsWith(suffix)));
                 if (shouldIgnoreNode) {
                     return;
                 }
-                const validIds = node.fields.filter(field => {
+                const validIds = (_c = node.fields) === null || _c === void 0 ? void 0 : _c.filter(field => {
                     const fieldNode = field.rawNode();
                     const isValidIdName = options.acceptedIdNames.includes(fieldNode.name.value);
                     // To be a valid type, it must be non-null and one of the accepted types.
@@ -145,7 +145,7 @@ export const rule = {
                 // Usually, there should be only one unique identifier field per type.
                 // Some clients allow multiple fields to be used. If more people need this,
                 // we can extend this rule later.
-                if (validIds.length !== 1) {
+                if ((validIds === null || validIds === void 0 ? void 0 : validIds.length) !== 1) {
                     const pluralNamesSuffix = options.acceptedIdNames.length > 1 ? 's' : '';
                     const pluralTypesSuffix = options.acceptedIdTypes.length > 1 ? 's' : '';
                     context.report({

package/esm/rules/unique-fragment-name.js

@@ -24,6 +24,7 @@ export const checkNode = (context, node, ruleId) => {
                     .map(f => `\t${relative(CWD, f.filePath.replace(VIRTUAL_DOCUMENT_REGEX, ''))}`)
                     .join('\n'),
             },
+            // @ts-expect-error name will exist
             node: node.name,
         });
     }

package/esm/schema.js

@@ -30,7 +30,9 @@ export function getSchema(project, schemaOptions) {
         schemaCache.set(schemaKey, schema);
     }
     catch (error) {
-        error.message = chalk.red(`Error while loading schema: ${error.message}`);
+        if (error instanceof Error) {
+            error.message = chalk.red(`Error while loading schema: ${error.message}`);
+        }
         schema = error;
     }
     return schema;

package/esm/testkit.js

@@ -1,6 +1,6 @@
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
-/* eslint-env jest */
+/* eslint-env vitest */
 import { readFileSync } from 'fs';
 import { resolve } from 'path';
 import { RuleTester, Linter } from 'eslint';
@@ -59,7 +59,7 @@ export class GraphQLRuleTester extends RuleTester {
         //     continue;
         //   }
         //
-        //   const verifyConfig = getVerifyConfig(ruleId, this.config, testCase);
+        //   const verifyConfig = getVerifyConfig<Options>(ruleId, this.config, testCase);
         //   defineParser(linter, verifyConfig.parser);
         //
         //   const messages = linter.verify(code, verifyConfig, { filename });
@@ -93,11 +93,10 @@ export class GraphQLRuleTester extends RuleTester {
                 }
                 const codeWithMessage = printCode(code, message, 1);
                 messageForSnapshot.push(printWithIndex('#### ❌ Error', index, messages.length), indentCode(codeWithMessage));
-                const { suggestions } = message;
                 // Don't print suggestions in snapshots for too big codes
-                if (suggestions && (code.match(/\n/g) || '').length < 1000) {
+                if (message.suggestions && (code.match(/\n/g) || '').length < 1000) {
                     for (const [i, suggestion] of message.suggestions.entries()) {
-                        const title = printWithIndex('#### 💡 Suggestion', i, suggestions.length, suggestion.desc);
+                        const title = printWithIndex('#### 💡 Suggestion', i, message.suggestions.length, suggestion.desc);
                         const output = applyFix(code, suggestion.fix);
                         const codeFrame = printCode(output, { line: 0, column: 0 });
                         messageForSnapshot.push(title, indentCode(codeFrame, 2));
@@ -110,9 +109,7 @@ export class GraphQLRuleTester extends RuleTester {
                     messageForSnapshot.push('#### 🔧 Autofix output', indentCode(printCode(output)));
                 }
             }
-            // @ts-expect-error -- we should import `vitest` but somebody could use globals from `jest`
             it(name || `Invalid #${idx + 1}`, () => {
-                // @ts-expect-error -- ^ same
                 expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
             });
         }

package/esm/utils.js

@@ -19,15 +19,17 @@ export function requireGraphQLSchemaFromContext(ruleId, context) {
     return schema;
 }
 export const logger = {
+    error: (...args) => 
     // eslint-disable-next-line no-console
-    error: (...args) => console.error(chalk.red('error'), '[graphql-eslint]', chalk(...args)),
+    console.error(chalk.red('error'), '[graphql-eslint]', chalk(...args)),
+    warn: (...args) => 
     // eslint-disable-next-line no-console
-    warn: (...args) => console.warn(chalk.yellow('warning'), '[graphql-eslint]', chalk(...args)),
+    console.warn(chalk.yellow('warning'), '[graphql-eslint]', chalk(...args)),
 };
 export const normalizePath = (path) => (path || '').replace(/\\/g, '/');
 export const VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/;
 export const CWD = process.cwd();
-export const getTypeName = (node) => 'type' in node ? getTypeName(node.type) : node.name.value;
+export const getTypeName = (node) => 'type' in node ? getTypeName(node.type) : 'name' in node && node.name ? node.name.value : '';
 export const TYPES_KINDS = [
     Kind.OBJECT_TYPE_DEFINITION,
     Kind.INTERFACE_TYPE_DEFINITION,
@@ -80,4 +82,7 @@ export const ARRAY_DEFAULT_OPTIONS = {
         type: 'string',
     },
 };
-export const englishJoinWords = words => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(words);
+export const englishJoinWords = (words) => new Intl.ListFormat('en-US', { type: 'disjunction' }).format(words);
+export function truthy(value) {
+    return Boolean(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.14.3-alpha-20221228000849-7bb2626",
+  "version": "3.14.4-alpha-20221229151835-f439b5b",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {