feat(eslint-plugin): [member-ordering] add a required option for required vs. optional member ordering

packages/eslint-plugin/src/rules/member-ordering.ts

@@ -4,7 +4,10 @@ import naturalCompare from 'natural-compare-lite';
 
 import * as util from '../util';
 
-export type MessageIds = 'incorrectGroupOrder' | 'incorrectOrder';
+export type MessageIds =
+  | 'incorrectGroupOrder'
+  | 'incorrectOrder'
+  | 'incorrectRequiredFirstOrder';
 
 type MemberKind =
   | 'call-signature'
@@ -46,6 +49,7 @@ type Order = AlphabeticalOrder | 'as-written';
 interface SortedOrderConfig {
   memberTypes?: MemberType[] | 'never';
   order: Order;
+  requiredFirst?: boolean;
 }
 
 type OrderConfig = MemberType[] | SortedOrderConfig | 'never';
@@ -99,6 +103,9 @@ const objectConfig = (memberTypes: MemberType[]): JSONSchema.JSONSchema4 => ({
         'natural-case-insensitive',
       ],
     },
+    requiredFirst: {
+      type: 'boolean',
+    },
   },
   additionalProperties: false,
 });
@@ -376,6 +383,57 @@ function getMemberName(
   }
 }
 
+/**
+ * Returns true if the member is optional based on the member type.
+ *
+ * @param node the node to be evaluated.
+ *
+ * @returns {Boolean} Returns true if the member is optional, false if it is not and undefined if it cannot be optional at all.
+ */
+function isMemberOptional(node: Member): boolean | undefined {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSPropertySignature:
+    case AST_NODE_TYPES.TSMethodSignature:
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.MethodDefinition:
+      return node.optional;
+    case AST_NODE_TYPES.TSConstructSignatureDeclaration:
+    case AST_NODE_TYPES.TSCallSignatureDeclaration:
+    case AST_NODE_TYPES.TSIndexSignature:
+    case AST_NODE_TYPES.StaticBlock:
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Gets the index of the last required member in the array.
+ *
+ * @example
+ * // returns 5
+ * getIndexOfLastRequiredMember([ req, req, req, optional, req, req, optional ])
+ * //                              0    1    2      3       4    5      6
+ *
+ * @param {Member[]} members An array of Member nodes containing required and optional items.
+ *
+ * @returns {Number} Returns the index of the element if it finds it or -1 otherwise.
+ */
+function getIndexOfLastRequiredMember(members: Member[]): number {
+  let idx = members.length - 1;
+
+  while (idx >= 0) {
+    const isMemberRequired = !isMemberOptional(members[idx]);
+    if (isMemberRequired) {
+      return idx;
+    }
+    idx--;
+  }
+
+  return -1;
+}
+
 /**
  * Gets the calculated rank using the provided method definition.
  * The algorithm is as follows:
@@ -525,6 +583,7 @@ export default util.createRule<Options, MessageIds>({
         'Member {{member}} should be declared before member {{beforeMember}}.',
       incorrectGroupOrder:
         'Member {{name}} should be declared before all {{rank}} definitions.',
+      incorrectRequiredFirstOrder: `Required {{member}} should be declared before optional member {{beforeMember}}.`,
     },
     schema: [
       {
@@ -689,6 +748,45 @@ export default util.createRule<Options, MessageIds>({
       }
     }
 
+    /**
+     * Checks if all required members appear before all optional members.
+     *
+     * @param {Member[]} members Members to be validated.
+     *
+     * @return True if all required and optional members are correctly sorted.
+     */
+    function checkRequiredFirstOrder(members: Member[]): boolean {
+      const lastRequiredMemberIndex = getIndexOfLastRequiredMember(members);
+      const firstOptionalMemberIndex = members.findIndex(member =>
+        isMemberOptional(member),
+      );
+
+      // if the array is either all required members or all optional members
+      // then its already in required first order
+      if (firstOptionalMemberIndex === -1 || lastRequiredMemberIndex === -1) {
+        return true;
+      }
+
+      if (firstOptionalMemberIndex < lastRequiredMemberIndex) {
+        context.report({
+          messageId: 'incorrectRequiredFirstOrder',
+          loc: members[firstOptionalMemberIndex].loc,
+          data: {
+            member: getMemberName(
+              members[lastRequiredMemberIndex],
+              context.getSourceCode(),
+            ),
+            beforeMember: getMemberName(
+              members[firstOptionalMemberIndex],
+              context.getSourceCode(),
+            ),
+          },
+        });
+      }
+
+      return firstOptionalMemberIndex > lastRequiredMemberIndex;
+    }
+
     /**
      * Validates if all members are correctly sorted.
      *
@@ -707,34 +805,79 @@ export default util.createRule<Options, MessageIds>({
 
       // Standardize config
       let order: Order | undefined;
-      let memberTypes;
+      let memberTypes: string | MemberType[] | undefined;
+      let requiredFirst: boolean | undefined = false;
+
+      const memberSets: Array<Member[]> = [];
+
+      const checkOrder = (memberSet: Member[]): void => {
+        const hasAlphaSort = !!(order && order !== 'as-written');
+
+        // Check order
+        if (Array.isArray(memberTypes)) {
+          const grouped = checkGroupSort(
+            memberSet,
+            memberTypes,
+            supportsModifiers,
+          );
+
+          if (grouped === null) {
+            return;
+          }
+
+          if (hasAlphaSort) {
+            grouped.some(
+              groupMember =>
+                !checkAlphaSort(groupMember, order as AlphabeticalOrder),
+            );
+          }
+        } else if (hasAlphaSort) {
+          checkAlphaSort(memberSet, order as AlphabeticalOrder);
+        }
+      };
 
       if (Array.isArray(orderConfig)) {
         memberTypes = orderConfig;
       } else {
         order = orderConfig.order;
         memberTypes = orderConfig.memberTypes;
+        requiredFirst = orderConfig.requiredFirst;
       }
 
-      const hasAlphaSort = !!(order && order !== 'as-written');
+      if (requiredFirst) {
+        if (!checkRequiredFirstOrder(members)) {
+          return;
+        }
 
-      // Check order
-      if (Array.isArray(memberTypes)) {
-        const grouped = checkGroupSort(members, memberTypes, supportsModifiers);
+        // if the order of required and optional elements is correct,
+        // then check for correct order within the required and
+        // optional member sets
+        const lastRequiredMemberIndex = getIndexOfLastRequiredMember(members);
+        const firstOptionalMemberIndex = members.findIndex(member =>
+          isMemberOptional(member),
+        );
 
-        if (grouped === null) {
-          return;
+        if (lastRequiredMemberIndex != -1) {
+          const requiredMembers: Member[] = members.slice(
+            0,
+            lastRequiredMemberIndex + 1,
+          );
+          memberSets.push(requiredMembers);
         }
 
-        if (hasAlphaSort) {
-          grouped.some(
-            groupMember =>
-              !checkAlphaSort(groupMember, order as AlphabeticalOrder),
+        if (firstOptionalMemberIndex != -1) {
+          const optionalMembers: Member[] = members.slice(
+            firstOptionalMemberIndex,
           );
+          memberSets.push(optionalMembers);
         }
-      } else if (hasAlphaSort) {
-        checkAlphaSort(members, order as AlphabeticalOrder);
       }
+
+      if (memberSets.length === 0) {
+        memberSets.push(members);
+      }
+
+      memberSets.forEach(checkOrder);
     }
 
     return {

packages/eslint-plugin/tests/rules/member-ordering/member-ordering-required-first.test.ts

@@ -0,0 +1,122 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+
+import type { MessageIds, Options } from '../../../src/rules/member-ordering';
+import rule from '../../../src/rules/member-ordering';
+import { RuleTester } from '../../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+});
+
+const grouped: TSESLint.RunTests<MessageIds, Options> = {
+  valid: [
+    {
+      code: `
+interface X {
+  c: string;
+  b?: string;
+  d?: string;
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'alphabetically',
+            requiredFirst: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  b?: string;
+  c?: string;
+  d?: string;
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'as-written',
+            requiredFirst: true,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  b: string;
+  c: string;
+  d: string;
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'as-written',
+            requiredFirst: true,
+          },
+        },
+      ],
+    },
+  ],
+  invalid: [
+    {
+      code: `
+interface X {
+  m: string;
+  d?: string;
+  b?: string;
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: 'never',
+            order: 'alphabetically',
+            requiredFirst: true,
+          },
+        },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          line: 5,
+          column: 3,
+        },
+      ],
+    },
+    {
+      code: `
+interface X {
+  a: string;
+  b?: string;
+  c: string;
+}
+      `,
+      options: [
+        {
+          default: {
+            memberTypes: ['call-signature', 'field', 'method'],
+            order: 'as-written',
+            requiredFirst: true,
+          },
+        },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectRequiredFirstOrder',
+          line: 4,
+          column: 3,
+        },
+      ],
+    },
+  ],
+};
+
+ruleTester.run('member-ordering-required-first', rule, grouped);