[Fix] order: codify invariants from docs into config schema

Author: Xunnamius

CHANGELOG.md

@@ -20,6 +20,7 @@ This change log adheres to standards from [Keep a CHANGELOG](https://keepachange
 - [`order`]: ensure arcane imports do not cause undefined behavior ([#3128], thanks [@Xunnamius])
 - [`order`]: resolve undefined property access issue when using `named` ordering ([#3166], thanks [@Xunnamius])
 - [`enforce-node-protocol-usage`]: avoid a crash with some TS code ([#3173], thanks [@ljharb])
+- [`order`]: codify invariants from docs into config schema ([#3152], thanks [@Xunnamius])
 
 ### Changed
 - [Docs] [`extensions`], [`order`]: improve documentation ([#3106], thanks [@Xunnamius])
@@ -1183,6 +1184,7 @@ for info on changes for earlier releases.
 [#3172]: https://github.com/import-js/eslint-plugin-import/pull/3172
 [#3167]: https://github.com/import-js/eslint-plugin-import/pull/3167
 [#3166]: https://github.com/import-js/eslint-plugin-import/pull/3166
+[#3152]: https://github.com/import-js/eslint-plugin-import/pull/3152
 [#3151]: https://github.com/import-js/eslint-plugin-import/pull/3151
 [#3138]: https://github.com/import-js/eslint-plugin-import/pull/3138
 [#3129]: https://github.com/import-js/eslint-plugin-import/pull/3129

src/rules/order.js

@@ -590,18 +590,14 @@ function getRequireBlock(node) {
 
 const types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index', 'object', 'type'];
 
-// Creates an object with type-rank pairs.
-// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }
-// Will throw an error if it contains a type that does not exist, or has a duplicate
+/**
+ * Creates an object with type-rank pairs.
+ *
+ * Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }
+ */
 function convertGroupsToRanks(groups) {
   const rankObject = groups.reduce(function (res, group, index) {
     [].concat(group).forEach(function (groupItem) {
-      if (types.indexOf(groupItem) === -1) {
-        throw new Error(`Incorrect configuration of the rule: Unknown type \`${JSON.stringify(groupItem)}\``);
-      }
-      if (res[groupItem] !== undefined) {
-        throw new Error(`Incorrect configuration of the rule: \`${groupItem}\` is duplicated`);
-      }
       res[groupItem] = index * 2;
     });
     return res;
@@ -858,6 +854,17 @@ module.exports = {
         properties: {
           groups: {
             type: 'array',
+            uniqueItems: true,
+            items: {
+              oneOf: [
+                { enum: types },
+                {
+                  type: 'array',
+                  uniqueItems: true,
+                  items: { enum: types },
+                },
+              ],
+            },
           },
           pathGroupsExcludedImportTypes: {
             type: 'array',
@@ -965,24 +972,72 @@ module.exports = {
         },
         additionalProperties: false,
         dependencies: {
+          sortTypesGroup: {
+            oneOf: [
+              {
+                // When sortTypesGroup is true, groups must NOT be an array that does not contain 'type'
+                properties: {
+                  sortTypesGroup: { enum: [true] },
+                  groups: {
+                    not: {
+                      type: 'array',
+                      uniqueItems: true,
+                      items: {
+                        oneOf: [
+                          { enum: types.filter((t) => t !== 'type') },
+                          {
+                            type: 'array',
+                            uniqueItems: true,
+                            items: { enum: types.filter((t) => t !== 'type') },
+                          },
+                        ],
+                      },
+                    },
+                  },
+                },
+                required: ['groups'],
+              },
+              {
+                properties: {
+                  sortTypesGroup: { enum: [false] },
+                },
+              },
+            ],
+          },
           'newlines-between-types': {
             properties: {
               sortTypesGroup: { enum: [true] },
             },
             required: ['sortTypesGroup'],
           },
           consolidateIslands: {
-            anyOf: [{
-              properties: {
-                'newlines-between': { enum: ['always-and-inside-groups'] },
+            oneOf: [
+              {
+                properties: {
+                  consolidateIslands: { enum: ['inside-groups'] },
+                },
+                anyOf: [
+                  {
+                    properties: {
+                      'newlines-between': { enum: ['always-and-inside-groups'] },
+                    },
+                    required: ['newlines-between'],
+                  },
+                  {
+                    properties: {
+                      'newlines-between-types': { enum: ['always-and-inside-groups'] },
+                    },
+                    required: ['newlines-between-types'],
+                  },
+                ],
               },
-              required: ['newlines-between'],
-            }, {
-              properties: {
-                'newlines-between-types': { enum: ['always-and-inside-groups'] },
+              {
+                properties: {
+                  consolidateIslands: { enum: ['never'] },
+                },
               },
-              required: ['newlines-between-types'],
-            }] },
+            ],
+          },
         },
       },
     ],

tests/src/rules/order.js

@@ -1643,63 +1643,6 @@ ruleTester.run('order', rule, {
         message: '`async` import should occur before import of `path`',
       }],
     }),
-    // Setting the order for an unknown type
-    // should make the rule trigger an error and do nothing else
-    test({
-      code: `
-        var async = require('async');
-        var index = require('./');
-      `,
-      options: [{ groups: [
-        'index',
-        ['sibling', 'parent', 'UNKNOWN', 'internal'],
-      ] }],
-      errors: [{
-        message: 'Incorrect configuration of the rule: Unknown type `"UNKNOWN"`',
-      }],
-    }),
-    // Type in an array can't be another array, too much nesting
-    test({
-      code: `
-        var async = require('async');
-        var index = require('./');
-      `,
-      options: [{ groups: [
-        'index',
-        ['sibling', 'parent', ['builtin'], 'internal'],
-      ] }],
-      errors: [{
-        message: 'Incorrect configuration of the rule: Unknown type `["builtin"]`',
-      }],
-    }),
-    // No numbers
-    test({
-      code: `
-        var async = require('async');
-        var index = require('./');
-      `,
-      options: [{ groups: [
-        'index',
-        ['sibling', 'parent', 2, 'internal'],
-      ] }],
-      errors: [{
-        message: 'Incorrect configuration of the rule: Unknown type `2`',
-      }],
-    }),
-    // Duplicate
-    test({
-      code: `
-        var async = require('async');
-        var index = require('./');
-      `,
-      options: [{ groups: [
-        'index',
-        ['sibling', 'parent', 'parent', 'internal'],
-      ] }],
-      errors: [{
-        message: 'Incorrect configuration of the rule: `parent` is duplicated',
-      }],
-    }),
     // Mixing require and import should have import up top
     test({
       code: `
@@ -2511,7 +2454,7 @@ ruleTester.run('order', rule, {
             { pattern: '@namespace', group: 'external', position: 'after' },
             { pattern: '@namespace/**', group: 'external', position: 'after' },
           ],
-          pathGroupsExcludedImportTypes: ['@namespace'],
+          pathGroupsExcludedImportTypes: [],
         },
       ],
       errors: [
@@ -3554,38 +3497,6 @@ context('TypeScript', function () {
               },
             ],
           }),
-          // Option sortTypesGroup: true and 'type' omitted from groups
-          test({
-            code: `
-              import c from 'Bar';
-              import type { AA } from 'abc';
-              import a from 'foo';
-              import type { A } from 'foo';
-
-              import type { C } from 'dirA/Bar';
-              import b from 'dirA/bar';
-              import type { D } from 'dirA/bar';
-
-              import index from './';
-            `,
-            ...parserConfig,
-            options: [
-              {
-                alphabetize: { order: 'asc' },
-                groups: ['external', 'internal', 'index'],
-                pathGroups: [
-                  {
-                    pattern: 'dirA/**',
-                    group: 'internal',
-                  },
-                ],
-                'newlines-between': 'always',
-                pathGroupsExcludedImportTypes: [],
-                // Becomes a no-op without "type" in groups
-                sortTypesGroup: true,
-              },
-            ],
-          }),
           test({
             code: `
               import c from 'Bar';
@@ -6889,7 +6800,7 @@ flowRuleTester.run('order', rule, {
               },
             },
           ],
-          pathGroupsExcludedImportTypes: ['react'],
+          pathGroupsExcludedImportTypes: [],
           alphabetize: {
             order: 'asc',
           },