@akinon/eslint-plugin-projectzero 2.0.0-rc.7 → 2.0.0

package/CHANGELOG.md

@@ -1,20 +1,282 @@
 # @akinon/eslint-plugin-projectzero
 
-## 2.0.0-rc.7
+## 2.0.0
 
-## 1.24.0-rc.6
+## 2.0.0-beta.27
 
-## 1.24.0-rc.5
+## 2.0.0-beta.26
 
-## 1.24.0-rc.4
+## 2.0.0-beta.25
 
-## 1.24.0-rc.3
+## 2.0.0-beta.24
 
-## 1.24.0-rc.2
+## 2.0.0-beta.23
 
-## 1.24.0-rc.1
+## 2.0.0-beta.22
 
-## 1.24.0-rc.0
+## 2.0.0-beta.21
+
+## 2.0.0-beta.20
+
+## 1.126.0
+
+## 1.125.2
+
+## 1.125.1
+
+## 1.125.0
+
+## 1.124.0
+
+## 1.123.0
+
+## 1.122.0
+
+## 1.121.0
+
+## 1.120.0
+
+## 1.119.0
+
+## 1.118.0
+
+## 1.117.0
+
+## 1.116.0
+
+## 1.115.0
+
+## 1.114.0
+
+## 1.113.0
+
+## 1.112.0
+
+## 1.111.0
+
+## 1.110.0
+
+## 1.109.0
+
+## 1.108.0
+
+## 1.107.0
+
+## 1.106.0
+
+## 1.105.0
+
+### Minor Changes
+
+- 62779ee: ZERO-3668: Refactor check-menu-depth rule to simplify depth validation logic and remove unused error messages
+
+## 1.104.0
+
+## 1.103.0
+
+## 1.102.0
+
+## 1.101.0
+
+## 1.100.0
+
+### Minor Changes
+
+- e57cd93: ZERO-3460: prevent installment loop on payment method switch
+
+## 1.99.0
+
+### Minor Changes
+
+- d58538b: ZERO-3638: Enhance RC pipeline: add fetch, merge, and pre-release setup with conditional commit
+
+## 1.98.0
+
+## 1.97.0
+
+## 1.96.0
+
+## 1.95.0
+
+### Minor Changes
+
+- 3b47394: ZERO-3582: Enhance check-menu-depth rule to enforce depth parameter in getMenu calls and add corresponding error messages
+
+## 1.94.0
+
+## 1.93.0
+
+## 1.92.0
+
+## 1.91.0
+
+## 1.90.0
+
+## 1.89.0
+
+## 1.88.0
+
+## 1.87.0
+
+## 1.86.0
+
+## 1.85.0
+
+### Minor Changes
+
+- 443ea19: ZERO-3254: Add ESLint rule to enforce correct order of pre-order middlewares
+
+## 1.84.0
+
+## 1.83.0
+
+## 1.82.0
+
+## 1.81.0
+
+## 1.80.0
+
+## 1.79.0
+
+## 1.78.0
+
+## 1.77.0
+
+## 1.76.0
+
+## 1.75.0
+
+## 1.74.0
+
+## 1.73.0
+
+## 1.72.0
+
+## 1.71.0
+
+## 1.70.0
+
+## 1.69.0
+
+## 1.68.0
+
+## 1.67.0
+
+## 1.66.0
+
+## 1.65.0
+
+### Minor Changes
+
+- 5a4c607: ZERO-2764: Add case-warning rule to eslint-plugin-projectzero
+
+## 1.64.0
+
+## 1.63.0
+
+## 1.62.0
+
+## 1.61.0
+
+## 1.60.0
+
+## 1.59.0
+
+## 1.58.0
+
+## 1.57.0
+
+## 1.56.0
+
+### Minor Changes
+
+- 4d64ef7: ZERO-2611: Add check-sentry-options rule to eslint-plugin-projectzero
+
+## 1.55.0
+
+## 1.54.0
+
+### Minor Changes
+
+- c474780: ZERO-2666: Add rule to check menu depth
+
+## 1.53.0
+
+## 1.52.0
+
+## 1.51.0
+
+## 1.50.0
+
+## 1.49.0
+
+## 1.48.0
+
+## 1.47.0
+
+## 1.46.0
+
+## 1.45.0
+
+## 1.44.0
+
+## 1.43.0
+
+## 1.42.0
+
+## 1.41.0
+
+## 1.40.0
+
+## 1.39.0
+
+## 1.38.0
+
+## 1.37.0
+
+## 1.36.0
+
+## 1.35.0
+
+## 1.34.0
+
+## 1.33.2
+
+## 1.33.1
+
+## 1.33.0
+
+## 1.32.0
+
+## 1.31.1
+
+## 1.31.0
+
+## 1.30.2
+
+## 1.30.1
+
+## 1.30.0
+
+### Patch Changes
+
+- 073fbd2: ZERO-2503: Add check changeset control script
+
+## 1.29.0
+
+## 1.27.0
+
+## 1.26.0
+
+## 1.25.0
+
+## 1.24.1
+
+### Patch Changes
+
+- 95510c7: ZERO-2508: Enable rc branch pipeline and add check-publish-version step
+
+## 1.24.0
 
 ## 1.23.0
 

package/configs/core.ts

@@ -9,6 +9,9 @@ export default {
     '@akinon/projectzero/meta-data-import': 'error',
     '@akinon/projectzero/urls-without-slash': 'error',
     '@akinon/projectzero/invalid-imports': 'error',
+    '@akinon/projectzero/case-warning': 'warn',
+    '@akinon/projectzero/check-sentry-options': 'error',
+    '@akinon/projectzero/check-menu-depth': 'error',
     'no-restricted-syntax': [
       'error',
       {

package/dist/configs/core.js

@@ -11,6 +11,9 @@ exports.default = {
         '@akinon/projectzero/meta-data-import': 'error',
         '@akinon/projectzero/urls-without-slash': 'error',
         '@akinon/projectzero/invalid-imports': 'error',
+        '@akinon/projectzero/case-warning': 'warn',
+        '@akinon/projectzero/check-sentry-options': 'error',
+        '@akinon/projectzero/check-menu-depth': 'error',
         'no-restricted-syntax': [
             'error',
             {

package/dist/index.js

@@ -18,13 +18,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configs = void 0;
 __exportStar(require("./rules"), exports);

package/dist/rules/case-warning.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    (node.callee.property.name === 'toLocaleUpperCase' ||
+                        node.callee.property.name === 'toLocaleLowerCase')) {
+                    const args = node.arguments;
+                    if (args.length === 0) {
+                        context.report({
+                            node,
+                            messageId: 'noLocale'
+                        });
+                    }
+                }
+            }
+        };
+    },
+    meta: {
+        messages: {
+            noLocale: 'toLocaleUpperCase() or toLocaleLowerCase() should specify a locale for consistent behavior across different environments.'
+        },
+        type: 'problem',
+        fixable: 'code',
+        schema: []
+    },
+    defaultOptions: []
+});

package/dist/rules/check-locale.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const path = __importStar(require("path"));

package/dist/rules/check-menu-depth.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const types_1 = require("@typescript-eslint/types");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    create: function (context) {
+        return {
+            CallExpression(node) {
+                const { callee, arguments: args } = node;
+                if (callee.type !== types_1.AST_NODE_TYPES.Identifier ||
+                    callee.name !== 'getMenu' ||
+                    args.length === 0 ||
+                    args[0].type !== types_1.AST_NODE_TYPES.ObjectExpression) {
+                    return;
+                }
+                const depthProperty = args[0].properties.find((prop) => {
+                    var _a;
+                    return prop.type === types_1.AST_NODE_TYPES.Property &&
+                        prop.key.type === types_1.AST_NODE_TYPES.Identifier &&
+                        prop.key.name === 'depth' &&
+                        ((_a = prop.value) === null || _a === void 0 ? void 0 : _a.type) === types_1.AST_NODE_TYPES.Literal &&
+                        typeof prop.value.value === 'number' &&
+                        prop.value.value > 3;
+                });
+                if (depthProperty) {
+                    context.report({
+                        node: depthProperty,
+                        messageId: 'depthMessage'
+                    });
+                }
+            }
+        };
+    },
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        messages: {
+            depthMessage: 'A request for a menu deeper than 3 levels from the server can lead to unnecessary memory usage and unwanted outcomes. Therefore, sending a request for a 3-level menu on the client side and making additional requests on hover for deeper levels may be more efficient.'
+        },
+        schema: []
+    },
+    defaultOptions: []
+});

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',
+    'paymentOptionResetMiddleware',
+    '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',
+            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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+exports.default = utils_1.ESLintUtils.RuleCreator.withoutDocs({
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.object &&
+                    callee.object.name === 'Sentry' &&
+                    callee.property &&
+                    callee.property.name === 'init') {
+                    const optionsArgument = node
+                        .arguments[0];
+                    if (optionsArgument && optionsArgument.type === 'ObjectExpression') {
+                        optionsArgument.properties.forEach((property) => {
+                            if (property.type === 'Property') {
+                                const key = property.key.name;
+                                if (key === 'dsn') {
+                                    const dsnValue = property.value;
+                                    if (dsnValue.type === 'Literal' && !dsnValue.value) {
+                                        context.report({
+                                            node: property,
+                                            messageId: 'invalidDsn'
+                                        });
+                                    }
+                                    if (dsnValue.type === 'MemberExpression') {
+                                        const objectName = dsnValue.object
+                                            .name;
+                                        const propertyName = dsnValue.property.name;
+                                        if (objectName === 'process' && propertyName === 'env') {
+                                            return;
+                                        }
+                                    }
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+        };
+    },
+    meta: {
+        messages: {
+            invalidDsn: 'Sentry DSN should not be empty.'
+        },
+        type: 'problem',
+        fixable: 'code',
+        schema: []
+    },
+    defaultOptions: []
+});

package/dist/rules/index.js

@@ -14,6 +14,10 @@ const meta_data_import_1 = __importDefault(require("./meta-data-import"));
 const check_middleware_order_1 = __importDefault(require("./check-middleware-order"));
 const urls_without_slash_1 = __importDefault(require("./urls-without-slash"));
 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,
@@ -24,6 +28,10 @@ const rules = {
     'meta-data-import': meta_data_import_1.default,
     'check-middleware-order': check_middleware_order_1.default,
     'urls-without-slash': urls_without_slash_1.default,
-    'invalid-imports': invalid_imports_1.default
+    '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-pre-order-middleware-order': check_pre_order_middleware_order_1.default
 };
 exports.rules = rules;

package/dist/rules/link-import.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const path = __importStar(require("path"));

package/package.json

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

package/rules/case-warning.ts

@@ -0,0 +1,39 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { TSESTree } from '@typescript-eslint/types';
+
+type MessageIds = 'noLocale';
+type Options = readonly [];
+
+export default ESLintUtils.RuleCreator.withoutDocs<Options, MessageIds>({
+  create(context) {
+    return {
+      CallExpression(node: TSESTree.CallExpression) {
+        if (
+          node.callee.type === 'MemberExpression' &&
+          node.callee.property.type === 'Identifier' &&
+          (node.callee.property.name === 'toLocaleUpperCase' ||
+            node.callee.property.name === 'toLocaleLowerCase')
+        ) {
+          const args = node.arguments;
+
+          if (args.length === 0) {
+            context.report({
+              node,
+              messageId: 'noLocale'
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    messages: {
+      noLocale:
+        'toLocaleUpperCase() or toLocaleLowerCase() should specify a locale for consistent behavior across different environments.'
+    },
+    type: 'problem',
+    fixable: 'code',
+    schema: []
+  },
+  defaultOptions: []
+});

package/rules/check-menu-depth.ts

@@ -0,0 +1,48 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
+
+export default ESLintUtils.RuleCreator.withoutDocs({
+  create: function (context) {
+    return {
+      CallExpression(node) {
+        const { callee, arguments: args } = node;
+
+        if (
+          callee.type !== AST_NODE_TYPES.Identifier ||
+          callee.name !== 'getMenu' ||
+          args.length === 0 ||
+          args[0].type !== AST_NODE_TYPES.ObjectExpression
+        ) {
+          return;
+        }
+
+        const depthProperty = args[0].properties.find(
+          (prop) =>
+            prop.type === AST_NODE_TYPES.Property &&
+            prop.key.type === AST_NODE_TYPES.Identifier &&
+            prop.key.name === 'depth' &&
+            prop.value?.type === AST_NODE_TYPES.Literal &&
+            typeof prop.value.value === 'number' &&
+            prop.value.value > 3
+        );
+
+        if (depthProperty) {
+          context.report({
+            node: depthProperty,
+            messageId: 'depthMessage'
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    type: 'problem',
+    fixable: 'code',
+    messages: {
+      depthMessage:
+        'A request for a menu deeper than 3 levels from the server can lead to unnecessary memory usage and unwanted outcomes. Therefore, sending a request for a 3-level menu on the client side and making additional requests on hover for deeper levels may be more efficient.'
+    },
+    schema: []
+  },
+  defaultOptions: []
+});

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',
+  'paymentOptionResetMiddleware',
+  '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',
+      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

@@ -0,0 +1,61 @@
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+
+export default ESLintUtils.RuleCreator.withoutDocs({
+  create(context) {
+    return {
+      CallExpression(node: TSESTree.CallExpression) {
+        const callee = node.callee as TSESTree.MemberExpression;
+
+        if (
+          callee.object &&
+          (callee.object as TSESTree.Identifier).name === 'Sentry' &&
+          callee.property &&
+          (callee.property as TSESTree.Identifier).name === 'init'
+        ) {
+          const optionsArgument = node
+            .arguments[0] as TSESTree.ObjectExpression;
+
+          if (optionsArgument && optionsArgument.type === 'ObjectExpression') {
+            optionsArgument.properties.forEach((property) => {
+              if (property.type === 'Property') {
+                const key = (property.key as TSESTree.Identifier).name;
+
+                if (key === 'dsn') {
+                  const dsnValue = property.value;
+
+                  if (dsnValue.type === 'Literal' && !dsnValue.value) {
+                    context.report({
+                      node: property,
+                      messageId: 'invalidDsn'
+                    });
+                  }
+
+                  if (dsnValue.type === 'MemberExpression') {
+                    const objectName = (dsnValue.object as TSESTree.Identifier)
+                      .name;
+                    const propertyName = (
+                      dsnValue.property as TSESTree.Identifier
+                    ).name;
+
+                    if (objectName === 'process' && propertyName === 'env') {
+                      return;
+                    }
+                  }
+                }
+              }
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    messages: {
+      invalidDsn: 'Sentry DSN should not be empty.'
+    },
+    type: 'problem',
+    fixable: 'code',
+    schema: []
+  },
+  defaultOptions: []
+});

package/rules/index.ts

@@ -8,6 +8,10 @@ import metaDataImport from './meta-data-import';
 import checkMiddlewareOrder from './check-middleware-order';
 import urlsWithoutSlash from './urls-without-slash';
 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,
@@ -19,7 +23,11 @@ const rules = {
   'meta-data-import': metaDataImport,
   'check-middleware-order': checkMiddlewareOrder,
   'urls-without-slash': urlsWithoutSlash,
-  'invalid-imports': invalidImports
+  'invalid-imports': invalidImports,
+  'case-warning': caseWarning,
+  'check-sentry-options': checkSentryOptions,
+  'check-menu-depth': checkMenuDepth,
+  'check-pre-order-middleware-order': checkPreOrderMiddlewareOrder
 };
 
 export { rules };