@akinon/eslint-plugin-projectzero 2.0.0-beta.7 → 2.0.0-beta.8

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # @akinon/eslint-plugin-projectzero
 
+## 2.0.0-beta.8
+
 ## 2.0.0-beta.7
 
 ## 2.0.0-beta.6

package/dist/rules/check-pre-order-middleware-order.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const CORRECT_PRE_ORDER_MIDDLEWARE_ORDER = [
+    'shippingStepMiddleware',
+    'installmentOptionMiddleware',
+    'paymentOptionMiddleware',
+    'attributeBasedShippingOptionMiddleware',
+    'dataSourceShippingOptionMiddleware',
+    'shippingOptionMiddleware',
+    'setAddressMiddleware',
+    'deliveryOptionMiddleware',
+    'setPreOrderMiddleware',
+    'redirectionMiddleware',
+    'preOrderValidationMiddleware'
+];
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    create(context) {
+        function checkPreOrderMiddlewareOrder(node) {
+            if (!isPreOrderMiddlewaresDeclaration(node)) {
+                return;
+            }
+            const arrayExpression = node.init;
+            const foundOrder = extractMiddlewareNames(arrayExpression);
+            validateMiddlewareOrder(foundOrder, node);
+        }
+        function isPreOrderMiddlewaresDeclaration(node) {
+            var _a;
+            return (node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.id.name === 'preOrderMiddlewares' &&
+                ((_a = node.init) === null || _a === void 0 ? void 0 : _a.type) === utils_1.AST_NODE_TYPES.ArrayExpression);
+        }
+        function extractMiddlewareNames(arrayExpression) {
+            return arrayExpression.elements
+                .map((element) => {
+                if ((element === null || element === void 0 ? void 0 : element.type) === utils_1.AST_NODE_TYPES.Identifier) {
+                    return element.name;
+                }
+                return null;
+            })
+                .filter((name) => Boolean(name));
+        }
+        function validateMiddlewareOrder(foundOrder, node) {
+            for (let i = 0; i < foundOrder.length; i++) {
+                const middleware = foundOrder[i];
+                const correctIndex = CORRECT_PRE_ORDER_MIDDLEWARE_ORDER.indexOf(middleware);
+                if (correctIndex === -1) {
+                    context.report({
+                        node,
+                        messageId: 'unknownMiddleware',
+                        data: { middleware }
+                    });
+                    break;
+                }
+                if (i !== correctIndex) {
+                    context.report({
+                        node,
+                        messageId: 'incorrectPreOrderMiddlewarePosition',
+                        data: {
+                            middleware,
+                            currentPosition: i + 1,
+                            expectedPosition: correctIndex + 1
+                        }
+                    });
+                    break;
+                }
+            }
+        }
+        return {
+            VariableDeclarator: checkPreOrderMiddlewareOrder
+        };
+    },
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforces the correct order of pre-order middlewares',
+            // @ts-expect-error
+            recommended: 'error'
+        },
+        schema: [],
+        messages: {
+            incorrectPreOrderMiddlewarePosition: '{{middleware}} is at position {{currentPosition}}, but it should be at position {{expectedPosition}}.',
+            unknownMiddleware: '{{middleware}} is not recognized as a valid pre-order middleware.'
+        }
+    },
+    defaultOptions: []
+});

package/dist/rules/check-sentry-options.js

@@ -33,15 +33,6 @@ exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
                                         }
                                     }
                                 }
-                                if (key === 'tracesSampleRate') {
-                                    const traceRate = property.value.value;
-                                    if (traceRate !== 1.0) {
-                                        context.report({
-                                            node: property,
-                                            messageId: 'incorrectTraceRate'
-                                        });
-                                    }
-                                }
                             }
                         });
                     }
@@ -51,8 +42,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
     },
     meta: {
         messages: {
-            invalidDsn: 'Sentry DSN should not be empty.',
-            incorrectTraceRate: 'Sentry tracesSampleRate should be set to 1.0.'
+            invalidDsn: 'Sentry DSN should not be empty.'
         },
         type: 'problem',
         fixable: 'code',

package/dist/rules/index.js

@@ -17,6 +17,7 @@ const invalid_imports_1 = __importDefault(require("./invalid-imports"));
 const case_warning_1 = __importDefault(require("./case-warning"));
 const check_sentry_options_1 = __importDefault(require("./check-sentry-options"));
 const check_menu_depth_1 = __importDefault(require("./check-menu-depth"));
+const check_pre_order_middleware_order_1 = __importDefault(require("./check-pre-order-middleware-order"));
 const rules = {
     'client-url': client_url_1.default,
     'image-import': image_import_1.default,
@@ -30,6 +31,7 @@ const rules = {
     'invalid-imports': invalid_imports_1.default,
     'case-warning': case_warning_1.default,
     'check-sentry-options': check_sentry_options_1.default,
-    'check-menu-depth': check_menu_depth_1.default
+    'check-menu-depth': check_menu_depth_1.default,
+    'check-pre-order-middleware-order': check_pre_order_middleware_order_1.default
 };
 exports.rules = rules;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akinon/eslint-plugin-projectzero",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.8",
   "private": false,
   "description": "ESLint plugin for Project Zero Next",
   "main": "dist/index.js",

package/rules/check-pre-order-middleware-order.ts

@@ -0,0 +1,116 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESTree
+} from '@typescript-eslint/utils';
+import { RuleContext } from '@typescript-eslint/utils/dist/ts-eslint';
+
+const CORRECT_PRE_ORDER_MIDDLEWARE_ORDER = [
+  'shippingStepMiddleware',
+  'installmentOptionMiddleware',
+  'paymentOptionMiddleware',
+  'attributeBasedShippingOptionMiddleware',
+  'dataSourceShippingOptionMiddleware',
+  'shippingOptionMiddleware',
+  'setAddressMiddleware',
+  'deliveryOptionMiddleware',
+  'setPreOrderMiddleware',
+  'redirectionMiddleware',
+  'preOrderValidationMiddleware'
+];
+
+type MessageIds = 'incorrectPreOrderMiddlewarePosition' | 'unknownMiddleware';
+type Options = [];
+
+export default ESLintUtils.RuleCreator.withoutDocs({
+  create(context: RuleContext<MessageIds, Options>) {
+    function checkPreOrderMiddlewareOrder(
+      node: TSESTree.VariableDeclarator
+    ): void {
+      if (!isPreOrderMiddlewaresDeclaration(node)) {
+        return;
+      }
+
+      const arrayExpression = node.init as TSESTree.ArrayExpression;
+      const foundOrder = extractMiddlewareNames(arrayExpression);
+
+      validateMiddlewareOrder(foundOrder, node);
+    }
+
+    function isPreOrderMiddlewaresDeclaration(
+      node: TSESTree.VariableDeclarator
+    ): boolean {
+      return (
+        node.id.type === AST_NODE_TYPES.Identifier &&
+        node.id.name === 'preOrderMiddlewares' &&
+        node.init?.type === AST_NODE_TYPES.ArrayExpression
+      );
+    }
+
+    function extractMiddlewareNames(
+      arrayExpression: TSESTree.ArrayExpression
+    ): string[] {
+      return arrayExpression.elements
+        .map((element) => {
+          if (element?.type === AST_NODE_TYPES.Identifier) {
+            return element.name;
+          }
+          return null;
+        })
+        .filter((name): name is string => Boolean(name));
+    }
+
+    function validateMiddlewareOrder(
+      foundOrder: string[],
+      node: TSESTree.Node
+    ): void {
+      for (let i = 0; i < foundOrder.length; i++) {
+        const middleware = foundOrder[i];
+        const correctIndex =
+          CORRECT_PRE_ORDER_MIDDLEWARE_ORDER.indexOf(middleware);
+
+        if (correctIndex === -1) {
+          context.report({
+            node,
+            messageId: 'unknownMiddleware',
+            data: { middleware }
+          });
+          break;
+        }
+
+        if (i !== correctIndex) {
+          context.report({
+            node,
+            messageId: 'incorrectPreOrderMiddlewarePosition',
+            data: {
+              middleware,
+              currentPosition: i + 1,
+              expectedPosition: correctIndex + 1
+            }
+          });
+          break;
+        }
+      }
+    }
+
+    return {
+      VariableDeclarator: checkPreOrderMiddlewareOrder
+    };
+  },
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforces the correct order of pre-order middlewares',
+      // @ts-expect-error
+      recommended: 'error'
+    },
+    schema: [],
+    messages: {
+      incorrectPreOrderMiddlewarePosition:
+        '{{middleware}} is at position {{currentPosition}}, but it should be at position {{expectedPosition}}.',
+      unknownMiddleware:
+        '{{middleware}} is not recognized as a valid pre-order middleware.'
+    }
+  },
+  defaultOptions: []
+});

package/rules/check-sentry-options.ts

@@ -42,16 +42,6 @@ export default ESLintUtils.RuleCreator.withoutDocs({
                     }
                   }
                 }
-
-                if (key === 'tracesSampleRate') {
-                  const traceRate = (property.value as TSESTree.Literal).value;
-                  if (traceRate !== 1.0) {
-                    context.report({
-                      node: property,
-                      messageId: 'incorrectTraceRate'
-                    });
-                  }
-                }
               }
             });
           }
@@ -61,8 +51,7 @@ export default ESLintUtils.RuleCreator.withoutDocs({
   },
   meta: {
     messages: {
-      invalidDsn: 'Sentry DSN should not be empty.',
-      incorrectTraceRate: 'Sentry tracesSampleRate should be set to 1.0.'
+      invalidDsn: 'Sentry DSN should not be empty.'
     },
     type: 'problem',
     fixable: 'code',

package/rules/index.ts

@@ -11,6 +11,7 @@ import invalidImports from './invalid-imports';
 import caseWarning from './case-warning';
 import checkSentryOptions from './check-sentry-options';
 import checkMenuDepth from './check-menu-depth';
+import checkPreOrderMiddlewareOrder from './check-pre-order-middleware-order';
 
 const rules = {
   'client-url': clientUrl,
@@ -25,7 +26,8 @@ const rules = {
   'invalid-imports': invalidImports,
   'case-warning': caseWarning,
   'check-sentry-options': checkSentryOptions,
-  'check-menu-depth': checkMenuDepth
+  'check-menu-depth': checkMenuDepth,
+  'check-pre-order-middleware-order': checkPreOrderMiddlewareOrder
 };
 
 export { rules };