add lexicographical sorting rules for schema stitching support (#256)

* fix sorting to be lexicographical

In larger projects, GraphQL schema stitching is a standardized practice. When stitching, Query, Mutation, and Subscription types are not always merged together sorted. [graphql-js has provided a function lexicographicSortSchema](graphql/graphql-js#2036) to enable stitched schemas to be sorted at runtime. Originally, this library used default JS sorting which is alphabetical. This makes the alphabetical rules virtually unusable by larger projects.

* introduce new listIsLexicographical function

Rather than a breaking change, I'm proposing new rules as a feature. :)

* add lexicographical versions of alphabetical rules

alphabetical !== lexicographical in JS. Let's just support both from this lib for backwards compatibility reasons.

* udpate README.md

* add rulesOptions to configuration

* update expect helpers to take configurationOptions

* update listIsAlphabetical to support lexicographical order

* remove lexicographic rules and update alphabetical rules to use sortOrder config option

* update README.md and runner

Author: dustinsgoodman

README.md

@@ -34,6 +34,12 @@ Options:
 
     example: --rules fields-have-descriptions,types-have-descriptions
 
+  -o, --rules-options <rulesOptions>
+
+    configure the specified rules with the passed in configuration options
+
+    example: --rules-options '{"enum-values-sorted-alphabetically":{"sortOrder":"lexicographical"}'
+
   -i, --ignore <ignore list>
 
     ignore errors for specific schema members (see "Inline rule overrides" for an alternative way to do this)
@@ -159,7 +165,10 @@ For now, only `rules`, `customRulePaths` and `schemaPaths` can be configured in
   "graphql-schema-linter": {
     "rules": ["enum-values-sorted-alphabetically"],
     "schemaPaths": ["path/to/my/schema/files/**.graphql"],
-    "customRulePaths": ["path/to/my/custom/rules/*.js"]
+    "customRulePaths": ["path/to/my/custom/rules/*.js"],
+    "rulesOptions": {
+      "enum-values-sorted-alphabetically": { "sortOrder": "lexicographical" }
+    }
   }
 }
 ```
@@ -170,7 +179,10 @@ For now, only `rules`, `customRulePaths` and `schemaPaths` can be configured in
 {
   "rules": ["enum-values-sorted-alphabetically"],
   "schemaPaths": ["path/to/my/schema/files/**.graphql"],
-  "customRulePaths": ["path/to/my/custom/rules/*.js"]
+  "customRulePaths": ["path/to/my/custom/rules/*.js"],
+  "rulesOptions": {
+      "enum-values-sorted-alphabetically": { "sortOrder": "lexicographical" }
+    }
 }
 ```
 
@@ -181,6 +193,9 @@ module.exports = {
   rules: ['enum-values-sorted-alphabetically'],
   schemaPaths: ['path/to/my/schema/files/**.graphql'],
   customRulePaths: ['path/to/my/custom/rules/*.js'],
+  rulesOptions: {
+    'enum-values-sorted-alphabetically': { sortOrder: 'lexicographical' }
+  }
 };
 ```
 
@@ -252,7 +267,9 @@ This rule will validate that all enum values have a description.
 
 ### `enum-values-sorted-alphabetically`
 
-This rule will validate that all enum values are sorted alphabetically.
+This rule will validate that all enum values are sorted alphabetically. Accepts following rule options:
+
+- sortOrder: <String> - either 'alphabetical' or 'lexicographical', defaults: 'alphabetical'
 
 ### `fields-are-camel-cased`
 
@@ -264,7 +281,9 @@ This rule will validate that object type fields and interface type fields have a
 
 ### `input-object-fields-sorted-alphabetically`
 
-This rule will validate that all input object fields are sorted alphabetically.
+This rule will validate that all input object fields are sorted alphabetically. Accepts following rule options:
+
+- sortOrder: <String> - either 'alphabetical' or 'lexicographical', defaults: 'alphabetical'
 
 ### `input-object-values-are-camel-cased`
 
@@ -306,7 +325,9 @@ More specifically:
 
 ### `type-fields-sorted-alphabetically`
 
-This rule will validate that all type object fields are sorted alphabetically.
+This rule will validate that all type object fields are sorted alphabetically. Accepts following rule options:
+
+- sortOrder: <String> - either 'alphabetical' or 'lexicographical', defaults: 'alphabetical'
 
 ### `types-are-capitalized`
 

src/configuration.js

@@ -10,6 +10,7 @@ export class Configuration {
     options:
       - format: (required) `text` | `json`
       - rules: [string array] whitelist rules
+      - rulesOptions: [string to object] configuration options for rules. Example: "rulesOptions": { "enum-values-sorted-alphabetically": { "sortOrder": "lexicographical" } }
       - ignore: [string to string array object] ignore list for rules. Example: {"fields-have-descriptions": ["Obvious", "Query.obvious", "Query.something.obvious"]}
       - customRulePaths: [string array] path to additional custom rules to be loaded
       - commentDescriptions: [boolean] use old way of defining descriptions in GraphQL SDL
@@ -21,6 +22,7 @@ export class Configuration {
       customRulePaths: [],
       commentDescriptions: false,
       oldImplementsSyntax: false,
+      rulesOptions: {},
       ignore: {},
     };
 
@@ -113,6 +115,10 @@ export class Configuration {
     return this.getRulesFromPaths([this.builtInRulePaths]);
   }
 
+  getRulesOptions() {
+    return this.options.rulesOptions;
+  }
+
   getIgnoreList() {
     return this.options.ignore;
   }

src/options.js

@@ -29,6 +29,7 @@ export function loadOptionsFromConfigDir(configDirectory) {
 
     return {
       rules: cosmic.config.rules,
+      rulesOptions: cosmic.config.rulesOptions || {},
       ignore: cosmic.config.ignore || {},
       customRulePaths: customRulePaths || [],
       schemaPaths: schemaPaths,

src/rules/enum_values_sorted_alphabetically.js

@@ -1,20 +1,26 @@
 import { ValidationError } from '../validation_error';
 import listIsAlphabetical from '../util/listIsAlphabetical';
 
-export function EnumValuesSortedAlphabetically(context) {
+export function EnumValuesSortedAlphabetically(configuration, context) {
+  const ruleKey = 'enum-values-sorted-alphabetically';
   return {
     EnumTypeDefinition(node, key, parent, path, ancestors) {
       const enumValues = node.values.map((val) => {
         return val.name.value;
       });
 
-      const { isSorted, sortedList } = listIsAlphabetical(enumValues);
+      const { sortOrder = 'alphabetical' } =
+        configuration.getRulesOptions()[ruleKey] || {};
+      const { isSorted, sortedList } = listIsAlphabetical(
+        enumValues,
+        sortOrder
+      );
 
       if (!isSorted) {
         context.reportError(
           new ValidationError(
-            'enum-values-sorted-alphabetically',
-            `The enum \`${node.name.value}\` should be sorted alphabetically. ` +
+            ruleKey,
+            `The enum \`${node.name.value}\` should be sorted in ${sortOrder} order. ` +
               `Expected sorting: ${sortedList.join(', ')}`,
             [node]
           )

src/rules/input_object_fields_sorted_alphabetically.js

@@ -1,17 +1,21 @@
 import { ValidationError } from '../validation_error';
 import listIsAlphabetical from '../util/listIsAlphabetical';
 
-export function InputObjectFieldsSortedAlphabetically(context) {
+export function InputObjectFieldsSortedAlphabetically(configuration, context) {
+  const ruleKey = 'input-object-fields-sorted-alphabetically';
   return {
     InputObjectTypeDefinition(node) {
       const fieldList = (node.fields || []).map((field) => field.name.value);
-      const { isSorted, sortedList } = listIsAlphabetical(fieldList);
+
+      const { sortOrder = 'alphabetical' } =
+        configuration.getRulesOptions()[ruleKey] || {};
+      const { isSorted, sortedList } = listIsAlphabetical(fieldList, sortOrder);
 
       if (!isSorted) {
         context.reportError(
           new ValidationError(
-            'input-object-fields-sorted-alphabetically',
-            `The fields of input type \`${node.name.value}\` should be sorted alphabetically. ` +
+            ruleKey,
+            `The fields of input type \`${node.name.value}\` should be sorted in ${sortOrder} order. ` +
               `Expected sorting: ${sortedList.join(', ')}`,
             [node]
           )

src/rules/type_fields_sorted_alphabetically.js

@@ -1,17 +1,21 @@
 import { ValidationError } from '../validation_error';
 import listIsAlphabetical from '../util/listIsAlphabetical';
 
-export function TypeFieldsSortedAlphabetically(context) {
+export function TypeFieldsSortedAlphabetically(configuration, context) {
+  const ruleKey = 'type-fields-sorted-alphabetically';
   return {
     ObjectTypeDefinition(node) {
       const fieldList = (node.fields || []).map((field) => field.name.value);
-      const { isSorted, sortedList } = listIsAlphabetical(fieldList);
+
+      const { sortOrder = 'alphabetical' } =
+        configuration.getRulesOptions()[ruleKey] || {};
+      const { isSorted, sortedList } = listIsAlphabetical(fieldList, sortOrder);
 
       if (!isSorted) {
         context.reportError(
           new ValidationError(
-            'type-fields-sorted-alphabetically',
-            `The fields of object type \`${node.name.value}\` should be sorted alphabetically. ` +
+            ruleKey,
+            `The fields of object type \`${node.name.value}\` should be sorted in ${sortOrder} order. ` +
               `Expected sorting: ${sortedList.join(', ')}`,
             [node]
           )

src/runner.js

@@ -14,6 +14,10 @@ export async function run(stdout, stdin, stderr, argv) {
       '-r, --rules <rules>',
       'only the rules specified will be used to validate the schema. Example: fields-have-descriptions,types-have-descriptions'
     )
+    .option(
+      '-o, --rules-options <rulesOptions>',
+      'configure the specified rules with the passed in configuration options. example: {"enum-values-sorted-alphabetically":{"sortOrder":"lexicographical"}}'
+    )
     .option(
       '-i, --ignore <ignore list>',
       "ignore errors for specific schema members, example: {'fields-have-descriptions':['Obvious','Query.obvious','Query.something.obvious']}"
@@ -152,6 +156,10 @@ function getOptionsFromCommander(commander) {
     options.rules = commander.rules.split(',');
   }
 
+  if (commander.rulesOptions) {
+    options.rulesOptions = JSON.parse(commander.rulesOptions);
+  }
+
   if (commander.ignore) {
     options.ignore = JSON.parse(commander.ignore);
   }

src/util/arraysEqual.js

@@ -0,0 +1,9 @@
+/**
+ * @summary Returns `true` if two arrays have the same item values in the same order.
+ */
+export default function arraysEqual(a, b) {
+  for (var i = 0; i < a.length; ++i) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}

src/util/listIsAlphabetical.js

@@ -1,21 +1,18 @@
-/**
- * @summary Returns `true` if two arrays have the same item values in the same order.
- */
-function arraysEqual(a, b) {
-  for (var i = 0; i < a.length; ++i) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
+import arraysEqual from './arraysEqual';
 
 /**
  * @summary Returns `true` if the list is in alphabetical order,
  *   or an alphabetized list if not
  * @param {String[]} list Array of strings
  * @return {Object} { isSorted: Bool, sortedList: String[] }
  */
-export default function listIsAlphabetical(list) {
-  const sortedList = list.slice().sort();
+export default function listIsAlphabetical(list, sortOrder = 'alphabetical') {
+  let sortFn;
+  if (sortOrder === 'lexicographical') {
+    sortFn = (a, b) => a.localeCompare(b);
+  }
+
+  const sortedList = list.slice().sort(sortFn);
   return {
     isSorted: arraysEqual(list, sortedList),
     sortedList,

test/assertions.js

@@ -14,8 +14,18 @@ const DefaultSchema = `
   }
 `;
 
-export function expectFailsRule(rule, schemaSDL, expectedErrors = []) {
-  return expectFailsRuleWithConfiguration(rule, schemaSDL, {}, expectedErrors);
+export function expectFailsRule(
+  rule,
+  schemaSDL,
+  expectedErrors = [],
+  configurationOptions = {}
+) {
+  return expectFailsRuleWithConfiguration(
+    rule,
+    schemaSDL,
+    configurationOptions,
+    expectedErrors
+  );
 }
 
 export function expectFailsRuleWithConfiguration(
@@ -41,8 +51,8 @@ export function expectFailsRuleWithConfiguration(
   );
 }
 
-export function expectPassesRule(rule, schemaSDL) {
-  expectPassesRuleWithConfiguration(rule, schemaSDL, {});
+export function expectPassesRule(rule, schemaSDL, configurationOptions = {}) {
+  expectPassesRuleWithConfiguration(rule, schemaSDL, configurationOptions);
 }
 
 export function expectPassesRuleWithConfiguration(