@sarj/eslint-plugin 0.1.2 → 0.2.0

package/lib/index.js

@@ -1,12 +1,18 @@
 module.exports = {
   rules: {
     "zod-naming-convention": require("./rules/zod-naming-convention"),
+    "require-assert-never": require("./rules/require-assert-never"),
+    "require-zod-form-validation": require("./rules/require-zod-form-validation"),
+    "enforce-file-structure": require("./rules/enforce-file-structure"),
   },
   configs: {
     recommended: {
       plugins: ["sarj-eslint"],
       rules: {
         "sarj-eslint/zod-naming-convention": "warn",
+        "sarj-eslint/require-assert-never": "error",
+        "sarj-eslint/require-zod-form-validation": "error",
+        "sarj-eslint/enforce-file-structure": "warn",
       },
     },
   },

package/lib/rules/enforce-file-structure.js

@@ -0,0 +1,85 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce consistent file structure: imports → types → constants → functions → exports",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      incorrectOrder: "File structure violation: {{current}} should come after {{expected}}",
+      useServerDirective: "Server action files must start with 'use server' directive"
+    }
+  },
+  create(context) {
+    const filename = context.getFilename();
+    const isServerAction = filename.includes('/actions/') || filename.includes('action');
+
+    return {
+      Program(node) {
+        const body = node.body;
+        let currentSection = 0; // 0: imports, 1: types, 2: constants, 3: functions, 4: exports
+        const sections = ['imports', 'types', 'constants', 'functions', 'exports'];
+
+        // Check for "use server" directive in server action files
+        if (isServerAction) {
+          const firstNode = body[0];
+          if (!firstNode ||
+              firstNode.type !== 'ExpressionStatement' ||
+              firstNode.expression.type !== 'Literal' ||
+              firstNode.expression.value !== 'use server') {
+            context.report({
+              node: node,
+              messageId: "useServerDirective"
+            });
+          }
+        }
+
+        body.forEach(statement => {
+          let statementSection = getStatementSection(statement);
+
+          if (statementSection < currentSection) {
+            context.report({
+              node: statement,
+              messageId: "incorrectOrder",
+              data: {
+                current: sections[statementSection],
+                expected: sections[currentSection]
+              }
+            });
+          } else {
+            currentSection = Math.max(currentSection, statementSection);
+          }
+        });
+      }
+    };
+
+    function getStatementSection(statement) {
+      switch (statement.type) {
+        case 'ImportDeclaration':
+          return 0; // imports
+        case 'TSTypeAliasDeclaration':
+        case 'TSInterfaceDeclaration':
+        case 'TSEnumDeclaration':
+          return 1; // types
+        case 'VariableDeclaration':
+          // Check if it's a constant (const with UPPER_CASE or simple values)
+          if (statement.kind === 'const') {
+            const declarator = statement.declarations[0];
+            if (declarator && declarator.id.name === declarator.id.name.toUpperCase()) {
+              return 2; // constants
+            }
+          }
+          return 3; // functions (const fn = ...)
+        case 'FunctionDeclaration':
+          return 3; // functions
+        case 'ExportNamedDeclaration':
+        case 'ExportDefaultDeclaration':
+          return 4; // exports
+        default:
+          return 3; // default to functions
+      }
+    }
+  }
+};

package/lib/rules/require-assert-never.js

@@ -0,0 +1,46 @@
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require assertNever in switch statement default cases for exhaustive checking",
+      category: "Best Practices",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingAssertNever: "Switch statement default case must call assertNever() for exhaustive type checking"
+    }
+  },
+  create(context) {
+    return {
+      SwitchStatement(node) {
+        const defaultCase = node.cases.find(caseNode => caseNode.test === null);
+
+        if (defaultCase) {
+          const hasAssertNever = defaultCase.consequent.some(statement => {
+            // Check for ExpressionStatement containing CallExpression
+            if (statement.type === 'ExpressionStatement' &&
+                statement.expression.type === 'CallExpression') {
+              const callee = statement.expression.callee;
+              return callee.name === 'assertNever';
+            }
+            // Check for ThrowStatement with assertNever call
+            if (statement.type === 'ThrowStatement' &&
+                statement.argument.type === 'CallExpression') {
+              const callee = statement.argument.callee;
+              return callee.name === 'assertNever';
+            }
+            return false;
+          });
+
+          if (!hasAssertNever) {
+            context.report({
+              node: defaultCase,
+              messageId: "missingAssertNever"
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/lib/rules/require-zod-form-validation.js

@@ -0,0 +1,47 @@
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require Zod validation when parsing FormData",
+      category: "Best Practices",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingZodValidation: "FormData parsing must use Zod schema validation (e.g., Schema.parse())"
+    }
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        // Check for formData.get() calls
+        if (node.callee.type === 'MemberExpression' &&
+            node.callee.property.name === 'get' &&
+            node.callee.object.name === 'formData') {
+
+          // Check if this is inside a Zod .parse() call
+          let parent = node.parent;
+          let hasZodValidation = false;
+
+          // Traverse up to find if we're inside a .parse() call
+          while (parent) {
+            if (parent.type === 'CallExpression' &&
+                parent.callee.type === 'MemberExpression' &&
+                parent.callee.property.name === 'parse') {
+              hasZodValidation = true;
+              break;
+            }
+            parent = parent.parent;
+          }
+
+          if (!hasZodValidation) {
+            context.report({
+              node,
+              messageId: "missingZodValidation"
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/lib/rules/zod-naming-convention.js

@@ -4,10 +4,10 @@ module.exports = {
     docs: {
       description: "Enforce Zod schemas to be named with a Z prefix",
       category: "Stylistic Issues",
-      recommended: false,
+      recommended: false
     },
-    // fixable: "code", <- Remove this line
-    schema: [],
+    fixable: "code",
+    schema: []
   },
   create(context) {
     return {
@@ -17,31 +17,31 @@ module.exports = {
           node.init &&
           node.init.type === "CallExpression" &&
           node.init.callee &&
-          // Check direct calls like z.object()
-          ((node.init.callee.type === "MemberExpression" &&
-            node.init.callee.object &&
-            node.init.callee.object.name === "z") ||
+          (
+            // Check direct calls like z.object()
+            (node.init.callee.type === "MemberExpression" && 
+             node.init.callee.object && 
+             node.init.callee.object.name === "z") ||
             // Check chained calls like z.object().extend()
-            (node.init.callee.type === "MemberExpression" &&
-              node.init.callee.object &&
-              node.init.callee.object.callee &&
-              node.init.callee.object.callee.object &&
-              node.init.callee.object.callee.object.name === "z"))
+            (node.init.callee.type === "MemberExpression" && 
+             node.init.callee.object && 
+             node.init.callee.object.callee &&
+             node.init.callee.object.callee.object &&
+             node.init.callee.object.callee.object.name === "z")
+          )
         ) {
           const variableName = node.id.name;
           if (!variableName.startsWith("Z")) {
             context.report({
               node: node.id,
               message: "Zod schema names should start with Z",
-              // Remove the fix function below
-              // fix(fixer) {
-              //   return fixer.replaceText(node.id, `Z${variableName}`);
-              // },
+              fix(fixer) {
+                return fixer.replaceText(node.id, `Z${variableName}`);
+              },
             });
           }
         }
       },
     };
   },
-};
-
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Custom ESLint rules collection",
   "main": "lib/index.js",
   "publishConfig": {