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'
+  | 'incorrectRequiredMembersOrder';
 
 type MemberKind =
   | 'call-signature'
@@ -46,6 +49,7 @@ type Order = AlphabeticalOrder | 'as-written';
 interface SortedOrderConfig {
   memberTypes?: MemberType[] | 'never';
   order: Order;
+  required?: 'first' | 'last';
 }
 
 type OrderConfig = MemberType[] | SortedOrderConfig | 'never';
@@ -99,6 +103,10 @@ const objectConfig = (memberTypes: MemberType[]): JSONSchema.JSONSchema4 => ({
         'natural-case-insensitive',
       ],
     },
+    required: {
+      type: 'string',
+      enum: ['first', 'last'],
+    },
   },
   additionalProperties: false,
 });
@@ -376,6 +384,26 @@ function getMemberName(
   }
 }
 
+/**
+ * Returns true if the member is optional based on the member type.
+ *
+ * @param node the node to be evaluated.
+ *
+ * @returns Whether the member is optional, or false if it cannot be optional at all.
+ */
+function isMemberOptional(node: Member): boolean {
+  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;
+  }
+  return false;
+}
+
 /**
  * Gets the calculated rank using the provided method definition.
  * The algorithm is as follows:
@@ -525,6 +553,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.',
+      incorrectRequiredMembersOrder: `Member {{member}} should be declared after all {{optionalOrRequired}} members.`,
     },
     schema: [
       {
@@ -689,6 +718,54 @@ export default util.createRule<Options, MessageIds>({
       }
     }
 
+    /**
+     * Checks if the order of optional and required members is correct based
+     * on the given 'required' parameter.
+     *
+     * @param members Members to be validated.
+     *
+     * @return True if all required and optional members are correctly sorted.
+     */
+    function checkRequiredOrder(
+      members: Member[],
+      required: 'first' | 'last' | undefined,
+    ): boolean {
+      const switchIndex = members.findIndex(
+        (member, i) =>
+          i && isMemberOptional(member) !== isMemberOptional(members[i - 1]),
+      );
+
+      const report = (member: Member): void =>
+        context.report({
+          messageId: 'incorrectRequiredMembersOrder',
+          loc: member.loc,
+          data: {
+            member: getMemberName(member, context.getSourceCode()),
+            optionalOrRequired: required === 'first' ? 'required' : 'optional',
+          },
+        });
+
+      // if the optionality of the first item is correct (based on required)
+      // then the first 0 inclusive to switchIndex exclusive members all
+      // have the correct optionality
+      if (isMemberOptional(members[0]) !== (required === 'last')) {
+        report(members[0]);
+        return false;
+      }
+
+      for (let i = switchIndex + 1; i < members.length; i++) {
+        if (
+          isMemberOptional(members[i]) !==
+          isMemberOptional(members[switchIndex])
+        ) {
+          report(members[switchIndex]);
+          return false;
+        }
+      }
+
+      return true;
+    }
+
     /**
      * Validates if all members are correctly sorted.
      *
@@ -707,33 +784,62 @@ export default util.createRule<Options, MessageIds>({
 
       // Standardize config
       let order: Order | undefined;
-      let memberTypes;
+      let memberTypes: string | MemberType[] | undefined;
+      let required: 'first' | 'last' | undefined;
+
+      // returns true if everything is good and false if an error was reported
+      const checkOrder = (memberSet: Member[]): boolean => {
+        const hasAlphaSort = !!(order && order !== 'as-written');
+
+        // Check order
+        if (Array.isArray(memberTypes)) {
+          const grouped = checkGroupSort(
+            memberSet,
+            memberTypes,
+            supportsModifiers,
+          );
+
+          if (grouped === null) {
+            return false;
+          }
+
+          if (hasAlphaSort) {
+            return !grouped.some(
+              groupMember =>
+                !checkAlphaSort(groupMember, order as AlphabeticalOrder),
+            );
+          }
+        } else if (hasAlphaSort) {
+          return checkAlphaSort(memberSet, order as AlphabeticalOrder);
+        }
+
+        return true;
+      };
 
       if (Array.isArray(orderConfig)) {
         memberTypes = orderConfig;
       } else {
         order = orderConfig.order;
         memberTypes = orderConfig.memberTypes;
+        required = orderConfig.required;
       }
 
-      const hasAlphaSort = !!(order && order !== 'as-written');
+      if (!required) {
+        checkOrder(members);
+        return;
+      }
 
-      // Check order
-      if (Array.isArray(memberTypes)) {
-        const grouped = checkGroupSort(members, memberTypes, supportsModifiers);
+      const switchIndex = members.findIndex(
+        (member, i) =>
+          i && isMemberOptional(member) !== isMemberOptional(members[i - 1]),
+      );
 
-        if (grouped === null) {
+      if (switchIndex !== -1) {
+        if (!checkRequiredOrder(members, required)) {
           return;
         }
-
-        if (hasAlphaSort) {
-          grouped.some(
-            groupMember =>
-              !checkAlphaSort(groupMember, order as AlphabeticalOrder),
-          );
-        }
-      } else if (hasAlphaSort) {
-        checkAlphaSort(members, order as AlphabeticalOrder);
+        checkOrder(members.slice(0, switchIndex));
+        checkOrder(members.slice(switchIndex));
       }
     }
 

packages/eslint-plugin/src/util/misc.ts

@@ -180,6 +180,29 @@ function formatWordList(words: string[]): string {
   return [words.slice(0, -1).join(', '), words.slice(-1)[0]].join(' and ');
 }
 
+/**
+ * Iterates the array in reverse and returns the index of the first element it
+ * finds which passes the predicate function.
+ *
+ * @returns Returns the index of the element if it finds it or -1 otherwise.
+ */
+function findLastIndex<T>(
+  members: T[],
+  predicate: (member: T) => boolean | undefined | null,
+): number {
+  let idx = members.length - 1;
+
+  while (idx >= 0) {
+    const valid = predicate(members[idx]);
+    if (valid) {
+      return idx;
+    }
+    idx--;
+  }
+
+  return -1;
+}
+
 export {
   arrayGroupByToMap,
   arraysAreEqual,
@@ -194,4 +217,5 @@ export {
   MemberNameType,
   RequireKeys,
   upperCaseFirst,
+  findLastIndex,
 };