@graphql-eslint/eslint-plugin 3.8.0-alpha-fb12b01.0 → 3.8.0-alpha-8ddf2a4.0

package/index.mjs

@@ -202,43 +202,6 @@ function requireUsedFieldsFromContext(ruleName, context) {
     const siblings = requireSiblingsOperations(ruleName, context);
     return context.parserServices.usedFields(schema, siblings);
 }
-function getLexer(source) {
-    // GraphQL v14
-    const gqlLanguage = require('graphql/language');
-    if (gqlLanguage && gqlLanguage.createLexer) {
-        return gqlLanguage.createLexer(source, {});
-    }
-    // GraphQL v15
-    const { Lexer: LexerCls } = require('graphql');
-    if (LexerCls && typeof LexerCls === 'function') {
-        return new LexerCls(source);
-    }
-    throw new Error(`Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!`);
-}
-function extractTokens(source) {
-    const lexer = getLexer(source);
-    const tokens = [];
-    let token = lexer.advance();
-    while (token && token.kind !== '<EOF>') {
-        tokens.push({
-            type: token.kind,
-            loc: {
-                start: {
-                    line: token.line,
-                    column: token.column,
-                },
-                end: {
-                    line: token.line,
-                    column: token.column,
-                },
-            },
-            value: token.value,
-            range: [token.start, token.end],
-        });
-        token = lexer.advance();
-    }
-    return tokens;
-}
 const normalizePath = (path) => (path || '').replace(/\\/g, '/');
 /**
  * https://github.com/prettier/eslint-plugin-prettier/blob/76bd45ece6d56eb52f75db6b4a1efdd2efb56392/eslint-plugin-prettier.js#L71
@@ -308,21 +271,16 @@ const convertCase = (style, str) => {
             return lowerCase(str).replace(/ /g, '-');
     }
 };
-function getLocation(loc, fieldName = '', offset) {
-    const { start } = loc;
-    /*
-     * ESLint has 0-based column number
-     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
-     */
-    const { offsetStart = 1, offsetEnd = 1 } = offset !== null && offset !== void 0 ? offset : {};
+function getLocation(loc, fieldName = '') {
+    const { line, column } = loc.start;
     return {
         start: {
-            line: start.line,
-            column: start.column - offsetStart,
+            line,
+            column,
         },
         end: {
-            line: start.line,
-            column: start.column - offsetEnd + fieldName.length,
+            line,
+            column: column + fieldName.length,
         },
     };
 }
@@ -336,23 +294,16 @@ function validateDocument(context, schema = null, documentNode, rule) {
             ? validate(schema, documentNode, [rule])
             : validateSDL(documentNode, null, [rule]);
         for (const error of validationErrors) {
-            /*
-             * TODO: Fix ESTree-AST converter because currently it's incorrectly convert loc.end
-             * Example: loc.end always equal loc.start
-             *  {
-             *    token: {
-             *      type: 'Name',
-             *      loc: { start: { line: 4, column: 13 }, end: { line: 4, column: 13 } },
-             *      value: 'veryBad',
-             *      range: [ 40, 47 ]
-             *    }
-             *  }
-             */
             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);
+            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column - 1);
             context.report({
-                loc: getLocation({ start: error.locations[0] }, token === null || token === void 0 ? void 0 : token.value),
+                loc: token
+                    ? token.loc
+                    : {
+                        line,
+                        column: column - 1,
+                    },
                 message: error.message,
             });
         }
@@ -682,9 +633,10 @@ const argumentsEnum = [
 const rule = {
     meta: {
         type: 'suggestion',
+        fixable: 'code',
         docs: {
             category: ['Schema', 'Operations'],
-            description: 'Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.',
+            description: `Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more.`,
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/alphabetize.md',
             examples: [
                 {
@@ -842,24 +794,56 @@ const rule = {
     },
     create(context) {
         var _a, _b, _c, _d, _e;
+        const sourceCode = context.getSourceCode();
+        function isNodeAndCommentOnSameLine(node, comment) {
+            return node.loc.end.line === comment.loc.start.line;
+        }
+        function getBeforeComments(node) {
+            const commentsBefore = sourceCode.getCommentsBefore(node);
+            if (commentsBefore.length === 0) {
+                return [];
+            }
+            const tokenBefore = sourceCode.getTokenBefore(node);
+            if (tokenBefore) {
+                return commentsBefore.filter(comment => !isNodeAndCommentOnSameLine(tokenBefore, comment));
+            }
+            return commentsBefore;
+        }
+        function getRangeWithComments(node) {
+            const [firstBeforeComment] = getBeforeComments(node);
+            const [firstAfterComment] = sourceCode.getCommentsAfter(node);
+            const from = firstBeforeComment || node;
+            const to = firstAfterComment && isNodeAndCommentOnSameLine(node, firstAfterComment) ? firstAfterComment : node;
+            return [from.range[0], to.range[1]];
+        }
         function checkNodes(nodes) {
-            let prevName = null;
-            for (const node of nodes) {
-                const currName = node.name.value;
-                if (prevName && prevName > currName) {
-                    const isVariableNode = node.kind === Kind.VARIABLE;
-                    context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: isVariableNode ? 0 : 1 }),
-                        messageId: ALPHABETIZE,
-                        data: isVariableNode
-                            ? {
-                                currName: `$${currName}`,
-                                prevName: `$${prevName}`,
-                            }
-                            : { currName, prevName },
-                    });
+            // Starts from 1, ignore nodes.length <= 1
+            for (let i = 1; i < nodes.length; i += 1) {
+                const prevNode = nodes[i - 1];
+                const currNode = nodes[i];
+                const prevName = prevNode.name.value;
+                const currName = currNode.name.value;
+                // Compare with lexicographic order
+                if (prevName.localeCompare(currName) !== 1) {
+                    continue;
                 }
-                prevName = currName;
+                const isVariableNode = currNode.kind === Kind.VARIABLE;
+                context.report({
+                    node: currNode.name,
+                    messageId: ALPHABETIZE,
+                    data: isVariableNode
+                        ? {
+                            currName: `$${currName}`,
+                            prevName: `$${prevName}`,
+                        }
+                        : { currName, prevName },
+                    *fix(fixer) {
+                        const prevRange = getRangeWithComments(prevNode);
+                        const currRange = getRangeWithComments(currNode);
+                        yield fixer.replaceTextRange(prevRange, sourceCode.getText({ range: currRange }));
+                        yield fixer.replaceTextRange(currRange, sourceCode.getText({ range: prevRange }));
+                    },
+                });
             }
         }
         const opts = context.options[0];
@@ -1056,7 +1040,7 @@ const rule$2 = {
                 if (shouldCheckType(node.parent.parent)) {
                     const name = node.name.value;
                     context.report({
-                        loc: getLocation(node.loc, name),
+                        node: node.name,
                         message: `Input "${name}" should be called "input"`,
                     });
                 }
@@ -1078,7 +1062,7 @@ const rule$2 = {
                     if ((options.caseSensitiveInputType && node.name.value !== mutationName) ||
                         name.toLowerCase() !== mutationName.toLowerCase()) {
                         context.report({
-                            loc: getLocation(node.loc, name),
+                            node: node.name,
                             message: `InputType "${name}" name should be "${mutationName}"`,
                         });
                     }
@@ -1530,7 +1514,7 @@ const rule$4 = {
                 const [trailingUnderscores] = nodeName.match(/_*$/);
                 const suggestedName = leadingUnderscores + renameToName + trailingUnderscores;
                 context.report({
-                    loc: getLocation(node.loc, node.value),
+                    node,
                     message: `${nodeType} "${nodeName}" should ${errorMessage}`,
                     suggest: [
                         {
@@ -1588,7 +1572,7 @@ const rule$4 = {
             const name = node.value;
             const renameToName = name.replace(new RegExp(isLeading ? '^_+' : '_+$'), '');
             context.report({
-                loc: getLocation(node.loc, name),
+                node,
                 message: `${isLeading ? 'Leading' : 'Trailing'} underscores are not allowed`,
                 suggest: [
                     {
@@ -1704,7 +1688,7 @@ const rule$6 = {
                 for (const duplicate of duplicates) {
                     const enumName = duplicate.name.value;
                     context.report({
-                        loc: getLocation(duplicate.loc, enumName),
+                        node: duplicate.name,
                         message: `Case-insensitive enum values duplicates are not allowed! Found: "${enumName}"`,
                     });
                 }
@@ -1798,9 +1782,8 @@ const rule$7 = {
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.enumValue) {
                     if (typeInfo.enumValue.deprecationReason) {
-                        const enumValueName = node.value;
                         context.report({
-                            loc: getLocation(node.loc, enumValueName),
+                            node,
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'enum value',
@@ -1815,9 +1798,8 @@ const rule$7 = {
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.fieldDef) {
                     if (typeInfo.fieldDef.deprecationReason) {
-                        const fieldName = node.name.value;
                         context.report({
-                            loc: getLocation(node.loc, fieldName),
+                            node: node.name,
                             messageId: NO_DEPRECATED,
                             data: {
                                 type: 'field',
@@ -1889,12 +1871,11 @@ const rule$8 = {
         schema: [],
     },
     create(context) {
-        function checkNode(usedFields, fieldName, type, node) {
+        function checkNode(usedFields, type, node) {
+            const fieldName = node.value;
             if (usedFields.has(fieldName)) {
                 context.report({
-                    loc: getLocation((node.kind === Kind.FIELD && node.alias ? node.alias : node).loc, fieldName, {
-                        offsetEnd: node.kind === Kind.VARIABLE_DEFINITION ? 0 : 1,
-                    }),
+                    node,
                     messageId: NO_DUPLICATE_FIELDS,
                     data: {
                         type,
@@ -1910,21 +1891,20 @@ const rule$8 = {
             OperationDefinition(node) {
                 const set = new Set();
                 for (const varDef of node.variableDefinitions) {
-                    checkNode(set, varDef.variable.name.value, 'Operation variable', varDef);
+                    checkNode(set, 'Operation variable', varDef.variable.name);
                 }
             },
             Field(node) {
                 const set = new Set();
                 for (const arg of node.arguments) {
-                    checkNode(set, arg.name.value, 'Field argument', arg);
+                    checkNode(set, 'Field argument', arg.name);
                 }
             },
             SelectionSet(node) {
-                var _a;
                 const set = new Set();
                 for (const selection of node.selections) {
                     if (selection.kind === Kind.FIELD) {
-                        checkNode(set, ((_a = selection.alias) === null || _a === void 0 ? void 0 : _a.value) || selection.name.value, 'Field', selection);
+                        checkNode(set, 'Field', selection.alias || selection.name);
                     }
                 }
             },
@@ -1983,7 +1963,7 @@ const rule$9 = {
         schema: [],
     },
     create(context) {
-        const selector = `${Kind.DOCUMENT}[definitions.0.kind!=/^(${Kind.OPERATION_DEFINITION}|${Kind.FRAGMENT_DEFINITION})$/]`;
+        const selector = 'Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]';
         return {
             [selector](node) {
                 const rawNode = node.rawNode();
@@ -1996,7 +1976,10 @@ const rule$9 = {
                         if (!isEslintComment && line !== prev.line && next.kind === TokenKind.NAME && linesAfter < 2) {
                             context.report({
                                 messageId: HASHTAG_COMMENT,
-                                loc: getLocation({ start: { line, column } }),
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
                             });
                         }
                     }
@@ -2079,7 +2062,7 @@ const rule$a = {
             [selector](node) {
                 const typeName = node.value;
                 context.report({
-                    loc: getLocation(node.loc, typeName),
+                    node,
                     message: `Root type "${typeName}" is forbidden`,
                 });
             },
@@ -2132,7 +2115,7 @@ const rule$b = {
                 const graphQLType = schema.getType(typeName);
                 if (isScalarType(graphQLType)) {
                     context.report({
-                        loc: getLocation(node.loc, typeName),
+                        node,
                         message: `Unexpected scalar result type "${typeName}"`,
                     });
                 }
@@ -2188,7 +2171,7 @@ const rule$c = {
                                 typeName,
                             },
                             messageId: NO_TYPENAME_PREFIX,
-                            loc: getLocation(field.loc, lowerTypeName),
+                            node: field.name,
                         });
                     }
                 }
@@ -2266,7 +2249,7 @@ const rule$d = {
                 const typeName = node.name.value;
                 if (!reachableTypes.has(typeName)) {
                     context.report({
-                        loc: getLocation(node.name.loc, typeName, { offsetStart: node.kind === Kind.DIRECTIVE_DEFINITION ? 2 : 1 }),
+                        node: node.name,
                         messageId: UNREACHABLE_TYPE,
                         data: { typeName },
                         suggest: [
@@ -2355,7 +2338,7 @@ const rule$e = {
                     return;
                 }
                 context.report({
-                    loc: getLocation(node.loc, fieldName),
+                    node: node.name,
                     messageId: UNUSED_FIELD,
                     data: { fieldName },
                     suggest: [
@@ -2408,8 +2391,51 @@ function getBaseType(type) {
     }
     return type;
 }
-function convertRange(gqlLocation) {
-    return [gqlLocation.start, gqlLocation.end];
+function convertToken(token, type) {
+    const { line, column, end, start, value } = token;
+    return {
+        type,
+        value,
+        /*
+         * ESLint has 0-based column number
+         * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+         */
+        loc: {
+            start: {
+                line,
+                column: column - 1,
+            },
+            end: {
+                line,
+                column: column - 1 + (end - start),
+            },
+        },
+        range: [start, end],
+    };
+}
+function getLexer(source) {
+    // GraphQL v14
+    const gqlLanguage = require('graphql/language');
+    if (gqlLanguage && gqlLanguage.createLexer) {
+        return gqlLanguage.createLexer(source, {});
+    }
+    // GraphQL v15
+    const { Lexer: LexerCls } = require('graphql');
+    if (LexerCls && typeof LexerCls === 'function') {
+        return new LexerCls(source);
+    }
+    throw new Error('Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!');
+}
+function extractTokens(source) {
+    const lexer = getLexer(source);
+    const tokens = [];
+    let token = lexer.advance();
+    while (token && token.kind !== TokenKind.EOF) {
+        const result = convertToken(token, token.kind);
+        tokens.push(result);
+        token = lexer.advance();
+    }
+    return tokens;
 }
 function extractCommentsFromAst(loc) {
     if (!loc) {
@@ -2418,35 +2444,16 @@ function extractCommentsFromAst(loc) {
     const comments = [];
     let token = loc.startToken;
     while (token !== null) {
-        const { kind, value, line, column, start, end, next } = token;
-        if (kind === TokenKind.COMMENT) {
-            comments.push({
-                type: 'Block',
-                value,
-                loc: {
-                    start: { line, column },
-                    end: { line, column },
-                },
-                range: [start, end],
-            });
+        if (token.kind === TokenKind.COMMENT) {
+            const comment = convertToken(token, 
+            // `eslint-disable` directive works only with `Block` type comment
+            token.value.trimStart().startsWith('eslint') ? 'Block' : 'Line');
+            comments.push(comment);
         }
-        token = next;
+        token = token.next;
     }
     return comments;
 }
-function convertLocation(gqlLocation) {
-    return {
-        start: {
-            column: gqlLocation.startToken.column,
-            line: gqlLocation.startToken.line,
-        },
-        end: {
-            column: gqlLocation.endToken.column,
-            line: gqlLocation.endToken.line,
-        },
-        source: gqlLocation.source.body,
-    };
-}
 function isNodeWithDescription(obj) {
     var _a;
     return (_a = obj) === null || _a === void 0 ? void 0 : _a.description;
@@ -2532,7 +2539,7 @@ const rule$f = {
                 const deletionDateNode = node.arguments.find(arg => arg.name.value === argName);
                 if (!deletionDateNode) {
                     context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: 0 }),
+                        node: node.name,
                         messageId: MESSAGE_REQUIRE_DATE,
                     });
                     return;
@@ -2560,7 +2567,7 @@ const rule$f = {
                 const canRemove = Date.now() > deletionDateInMS;
                 if (canRemove) {
                     context.report({
-                        node,
+                        node: node.parent.name,
                         messageId: MESSAGE_CAN_BE_REMOVED,
                         data: {
                             nodeName: node.parent.name.value,
@@ -2617,7 +2624,7 @@ const rule$g = {
                 const value = reasonArg ? String(valueFromNode(reasonArg.value) || '').trim() : null;
                 if (!value) {
                     context.report({
-                        loc: getLocation(node.loc, node.name.value, { offsetEnd: 0 }),
+                        node: node.name,
                         message: 'Directive "@deprecated" must have a reason!',
                     });
                 }
@@ -2774,7 +2781,7 @@ const rule$h = {
                 }
                 if (description.length === 0) {
                     context.report({
-                        loc: isOperation ? getLocation(node.loc, node.operation) : getLocation(node.name.loc, node.name.value),
+                        loc: isOperation ? getLocation(node.loc, node.operation) : node.name.loc,
                         messageId: RULE_ID$2,
                         data: {
                             nodeName: getNodeName(node),
@@ -2847,7 +2854,7 @@ const rule$i = {
                     const hasQueryType = fields.some(field => getTypeName(field) === queryType.name);
                     if (!hasQueryType) {
                         context.report({
-                            loc: getLocation(node.loc, typeName),
+                            node,
                             message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`,
                         });
                     }
@@ -2867,16 +2874,30 @@ function convertToESTree(node, typeInfo) {
 function hasTypeField(obj) {
     return obj && !!obj.type;
 }
-/**
- * Strips tokens information from `location` object - this is needed since it's created as linked list in GraphQL-JS,
- * causing eslint to fail on circular JSON
- * @param location
- */
-function stripTokens(location) {
-    return {
-        end: location.end,
-        start: location.start,
+function convertLocation(location) {
+    const { startToken, endToken, source, start, end } = location;
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    const loc = {
+        start: {
+            /*
+             * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
+             */
+            line: startToken.line === 0 ? 1 : startToken.line,
+            column: startToken.column === 0 ? 0 : startToken.column - 1,
+        },
+        end: {
+            line: endToken.line,
+            column: endToken.column - 1,
+        },
+        source: source.body,
     };
+    if (loc.start.column === loc.end.column) {
+        loc.end.column += end - start;
+    }
+    return loc;
 }
 const convertNode = (typeInfo) => (node, key, parent) => {
     const calculatedTypeInfo = typeInfo
@@ -2896,7 +2917,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
         typeInfo: () => calculatedTypeInfo,
         leadingComments: convertDescription(node),
         loc: convertLocation(node.loc),
-        range: convertRange(node.loc),
+        range: [node.loc.start, node.loc.end],
     };
     if (hasTypeField(node)) {
         const { type: gqlType, loc: gqlLocation, ...rest } = node;
@@ -2921,7 +2942,6 @@ const convertNode = (typeInfo) => (node, key, parent) => {
                 }
                 return parent[key];
             },
-            gqlLocation: stripTokens(gqlLocation),
         };
         return estreeNode;
     }
@@ -2945,7 +2965,6 @@ const convertNode = (typeInfo) => (node, key, parent) => {
                 }
                 return parent[key];
             },
-            gqlLocation: stripTokens(gqlLocation),
         };
         return estreeNode;
     }
@@ -3196,9 +3215,13 @@ const rule$k = {
                     };
                     checkFn({
                         getDocument: () => document,
-                        reportError: (error) => {
+                        reportError(error) {
+                            const { line, column } = error.locations[0];
                             context.report({
-                                loc: getLocation({ start: error.locations[0] }),
+                                loc: {
+                                    line,
+                                    column: column - 1,
+                                },
                                 message: error.message,
                             });
                         },
@@ -3373,7 +3396,7 @@ const rule$l = {
                 // we can extend this rule later.
                 if (validIds.length !== 1) {
                     context.report({
-                        loc: getLocation(node.name.loc, typeName),
+                        node: node.name,
                         messageId: RULE_ID$5,
                         data: {
                             typeName,
@@ -3409,7 +3432,7 @@ const checkNode = (context, node, ruleName, messageId) => {
                     .map(f => `\t${relative(process.cwd(), getOnDiskFilepath(f.filePath))}`)
                     .join('\n'),
             },
-            loc: getLocation(node.name.loc, documentName),
+            node: node.name,
         });
     }
 };
@@ -3963,6 +3986,15 @@ function parseForESLint(code, options = {}) {
     }
 }
 
+function indentCode(code, indent = 4) {
+    return code.replace(/^/gm, ' '.repeat(indent));
+}
+function printCode(code) {
+    return codeFrameColumns(code, { start: { line: 0, column: 0 } }, {
+        linesAbove: Number.POSITIVE_INFINITY,
+        linesBelow: Number.POSITIVE_INFINITY,
+    });
+}
 class GraphQLRuleTester extends RuleTester {
     constructor(parserOptions = {}) {
         const config = {
@@ -4004,19 +4036,29 @@ class GraphQLRuleTester extends RuleTester {
         }
         const linter = new Linter();
         linter.defineRule(name, rule);
+        const hasOnlyTest = tests.invalid.some(t => t.only);
         for (const testCase of tests.invalid) {
+            const { only, code, filename } = testCase;
+            if (hasOnlyTest && !only) {
+                continue;
+            }
             const verifyConfig = getVerifyConfig(name, this.config, testCase);
             defineParser(linter, verifyConfig.parser);
-            const { code, filename } = testCase;
             const messages = linter.verify(code, verifyConfig, { filename });
-            for (const message of messages) {
+            const messageForSnapshot = [];
+            for (const [index, message] of messages.entries()) {
                 if (message.fatal) {
                     throw new Error(message.message);
                 }
-                const messageForSnapshot = visualizeEslintMessage(code, message);
-                // eslint-disable-next-line no-undef
-                expect(messageForSnapshot).toMatchSnapshot();
+                messageForSnapshot.push(`❌ Error ${index + 1}/${messages.length}`, visualizeEslintMessage(code, message));
+            }
+            if (rule.meta.fixable) {
+                const { fixed, output } = linter.verifyAndFix(code, verifyConfig, { filename });
+                if (fixed) {
+                    messageForSnapshot.push('🔧 Autofix output', indentCode(printCode(output), 2));
+                }
             }
+            expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
         }
     }
 }
@@ -4069,4 +4111,4 @@ function visualizeEslintMessage(text, result) {
     });
 }
 
-export { GraphQLRuleTester, configs, convertDescription, convertLocation, convertRange, convertToESTree, extractCommentsFromAst, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };
+export { GraphQLRuleTester, configs, convertDescription, convertToESTree, convertToken, extractCommentsFromAst, extractTokens, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.8.0-alpha-fb12b01.0",
+  "version": "3.8.0-alpha-8ddf2a4.0",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {

package/rules/alphabetize.d.ts

@@ -4,7 +4,7 @@ declare const valuesEnum: ['EnumTypeDefinition'];
 declare const selectionsEnum: ('OperationDefinition' | 'FragmentDefinition')[];
 declare const variablesEnum: ['OperationDefinition'];
 declare const argumentsEnum: ('FieldDefinition' | 'Field' | 'DirectiveDefinition' | 'Directive')[];
-declare type AlphabetizeConfig = {
+export declare type AlphabetizeConfig = {
     fields?: typeof fieldsEnum;
     values?: typeof valuesEnum;
     selections?: typeof selectionsEnum;