@sarj/eslint-plugin 0.2.1 → 1.0.0

package/dist/rules/require-assert-never.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from "eslint";
+/**
+ * @fileoverview Require assertNever in switch statement default cases
+ * @description Ensures exhaustive type checking in switch statements
+ */
+export declare const requireAssertNever: Rule.RuleModule;
+export default requireAssertNever;
+//# sourceMappingURL=require-assert-never.d.ts.map

package/dist/rules/require-assert-never.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-assert-never.d.ts","sourceRoot":"","sources":["../../src/rules/require-assert-never.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC;;;GAGG;AAEH,eAAO,MAAM,kBAAkB,EAAE,IAAI,CAAC,UAwDrC,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

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

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Require assertNever in switch statement default cases
+ * @description Ensures exhaustive type checking in switch statements
+ */
+export const requireAssertNever = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require assertNever in switch statement default cases for exhaustive type checking",
+            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) {
+                    return;
+                }
+                const hasAssertNever = defaultCase.consequent.some((statement) => {
+                    // Check for ExpressionStatement containing CallExpression
+                    if (statement.type === "ExpressionStatement") {
+                        const exprStmt = statement;
+                        if (exprStmt.expression.type === "CallExpression") {
+                            const callee = exprStmt.expression.callee;
+                            return callee.type === "Identifier" && callee.name === "assertNever";
+                        }
+                    }
+                    // Check for ThrowStatement with assertNever call
+                    if (statement.type === "ThrowStatement") {
+                        const throwStmt = statement;
+                        if (throwStmt.argument?.type === "CallExpression") {
+                            const callee = throwStmt.argument.callee;
+                            return callee.type === "Identifier" && callee.name === "assertNever";
+                        }
+                    }
+                    return false;
+                });
+                if (!hasAssertNever) {
+                    context.report({
+                        node: defaultCase,
+                        messageId: "missingAssertNever",
+                    });
+                }
+            },
+        };
+    },
+};
+export default requireAssertNever;

package/dist/rules/require-assert-never.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=require-assert-never.test.d.ts.map

package/dist/rules/require-assert-never.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-assert-never.test.d.ts","sourceRoot":"","sources":["../../src/rules/require-assert-never.test.ts"],"names":[],"mappings":""}

package/dist/rules/require-assert-never.test.js

@@ -0,0 +1,76 @@
+import { RuleTester } from "eslint";
+import { describe, it } from "vitest";
+import { requireAssertNever } from "./require-assert-never.js";
+const ruleTester = new RuleTester({
+    languageOptions: {
+        ecmaVersion: 2022,
+        sourceType: "module",
+    },
+});
+describe("require-assert-never", () => {
+    it("should pass valid and fail invalid cases", () => {
+        ruleTester.run("require-assert-never", requireAssertNever, {
+            valid: [
+                // Switch with assertNever in default case
+                {
+                    code: `
+            switch (status) {
+              case "active":
+                return 1;
+              default:
+                assertNever(status);
+            }
+          `,
+                },
+                // Switch with throw assertNever
+                {
+                    code: `
+            switch (type) {
+              case "a":
+                break;
+              default:
+                throw assertNever(type);
+            }
+          `,
+                },
+                // Switch without default case is OK
+                {
+                    code: `
+            switch (value) {
+              case 1:
+                return "one";
+              case 2:
+                return "two";
+            }
+          `,
+                },
+            ],
+            invalid: [
+                // Default case without assertNever
+                {
+                    code: `
+            switch (status) {
+              case "active":
+                return 1;
+              default:
+                return 0;
+            }
+          `,
+                    errors: [{ messageId: "missingAssertNever" }],
+                },
+                // Empty default case
+                {
+                    code: `
+            switch (type) {
+              case "a":
+                break;
+              default:
+                break;
+            }
+          `,
+                    errors: [{ messageId: "missingAssertNever" }],
+                },
+            ],
+        });
+    });
+});

package/dist/rules/require-zod-form-validation.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from "eslint";
+/**
+ * @fileoverview Require Zod validation when parsing FormData
+ * @description Ensures form data is validated with Zod schemas
+ */
+export declare const requireZodFormValidation: Rule.RuleModule;
+export default requireZodFormValidation;
+//# sourceMappingURL=require-zod-form-validation.d.ts.map

package/dist/rules/require-zod-form-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-zod-form-validation.d.ts","sourceRoot":"","sources":["../../src/rules/require-zod-form-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC;;;GAGG;AAEH,eAAO,MAAM,wBAAwB,EAAE,IAAI,CAAC,UAkE3C,CAAC;AAEF,eAAe,wBAAwB,CAAC"}

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

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview Require Zod validation when parsing FormData
+ * @description Ensures form data is validated with Zod schemas
+ */
+export const requireZodFormValidation = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require Zod validation when parsing FormData",
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            missingZodValidation: "FormData parsing must use Zod schema validation (e.g., Schema.parse())",
+        },
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callExpr = node;
+                // Check for formData.get() calls
+                if (callExpr.callee.type !== "MemberExpression") {
+                    return;
+                }
+                const callee = callExpr.callee;
+                if (callee.property.type !== "Identifier" ||
+                    callee.property.name !== "get" ||
+                    callee.object.type !== "Identifier" ||
+                    callee.object.name !== "formData") {
+                    return;
+                }
+                // Check if this is inside a Zod .parse() call
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                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") {
+                        const parentCallee = parent.callee;
+                        if (parentCallee.property.type === "Identifier" &&
+                            parentCallee.property.name === "parse") {
+                            hasZodValidation = true;
+                            break;
+                        }
+                    }
+                    parent = parent.parent;
+                }
+                if (!hasZodValidation) {
+                    context.report({
+                        node: node,
+                        messageId: "missingZodValidation",
+                    });
+                }
+            },
+        };
+    },
+};
+export default requireZodFormValidation;

package/dist/rules/zod-naming-convention.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from "eslint";
+/**
+ * @fileoverview Enforce Zod schemas to be named with a Z prefix
+ * @description Ensures consistent naming for Zod schemas (e.g., ZUserSchema instead of userSchema)
+ */
+export declare const zodNamingConvention: Rule.RuleModule;
+export default zodNamingConvention;
+//# sourceMappingURL=zod-naming-convention.d.ts.map

package/dist/rules/zod-naming-convention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-naming-convention.d.ts","sourceRoot":"","sources":["../../src/rules/zod-naming-convention.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC;;;GAGG;AAEH,eAAO,MAAM,mBAAmB,EAAE,IAAI,CAAC,UAqDtC,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

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

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Enforce Zod schemas to be named with a Z prefix
+ * @description Ensures consistent naming for Zod schemas (e.g., ZUserSchema instead of userSchema)
+ */
+export const zodNamingConvention = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Enforce Zod schemas to be named with a Z prefix",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            zodPrefix: "Zod schema names should start with 'Z' (e.g., Z{{suggestedName}})",
+        },
+    },
+    create(context) {
+        return {
+            VariableDeclarator(node) {
+                const declarator = node;
+                if (!declarator.init || declarator.init.type !== "CallExpression") {
+                    return;
+                }
+                const callExpr = declarator.init;
+                if (!callExpr.callee || callExpr.callee.type !== "MemberExpression") {
+                    return;
+                }
+                const callee = callExpr.callee;
+                const isDirectZodCall = callee.object.type === "Identifier" &&
+                    callee.object.name === "z";
+                const isChainedZodCall = callee.object.type === "CallExpression" &&
+                    callee.object.callee?.type === "MemberExpression" &&
+                    callee.object.callee.object?.type === "Identifier" &&
+                    callee.object.callee.object.name === "z";
+                if (isDirectZodCall || isChainedZodCall) {
+                    if (declarator.id.type !== "Identifier") {
+                        return;
+                    }
+                    const variableName = declarator.id.name;
+                    if (!variableName.startsWith("Z")) {
+                        const suggestedName = variableName.charAt(0).toUpperCase() + variableName.slice(1);
+                        context.report({
+                            node: declarator.id,
+                            messageId: "zodPrefix",
+                            data: { suggestedName },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+export default zodNamingConvention;

package/dist/rules/zod-naming-convention.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=zod-naming-convention.test.d.ts.map

package/dist/rules/zod-naming-convention.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-naming-convention.test.d.ts","sourceRoot":"","sources":["../../src/rules/zod-naming-convention.test.ts"],"names":[],"mappings":""}

package/dist/rules/zod-naming-convention.test.js

@@ -0,0 +1,38 @@
+import { RuleTester } from "eslint";
+import { describe, it } from "vitest";
+import { zodNamingConvention } from "./zod-naming-convention.js";
+const ruleTester = new RuleTester({
+    languageOptions: {
+        ecmaVersion: 2022,
+        sourceType: "module",
+    },
+});
+describe("zod-naming-convention", () => {
+    it("should pass valid and fail invalid cases", () => {
+        ruleTester.run("zod-naming-convention", zodNamingConvention, {
+            valid: [
+                // Correct naming with Z prefix
+                { code: 'const ZUserSchema = z.object({ name: z.string() });' },
+                { code: 'const ZConfig = z.object({ port: z.number() });' },
+                { code: 'const ZResponse = z.object({}).extend({});' },
+                // Non-Zod variables are fine
+                { code: 'const userSchema = createSchema();' },
+                { code: 'const config = { name: "test" };' },
+            ],
+            invalid: [
+                {
+                    code: 'const userSchema = z.object({ name: z.string() });',
+                    errors: [{ messageId: "zodPrefix" }],
+                },
+                {
+                    code: 'const schema = z.string();',
+                    errors: [{ messageId: "zodPrefix" }],
+                },
+                {
+                    code: 'const config = z.object({}).extend({ port: z.number() });',
+                    errors: [{ messageId: "zodPrefix" }],
+                },
+            ],
+        });
+    });
+});

package/package.json

@@ -1,30 +1,52 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "0.2.1",
-  "description": "Custom ESLint rules collection",
-  "main": "lib/index.js",
+  "version": "1.0.0",
+  "description": "Custom ESLint rules collection for Sarj projects",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "test": "mocha tests/**/*.test.js"
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "prepublishOnly": "yarn build"
   },
   "keywords": [
     "eslint",
     "eslintplugin",
     "eslint-plugin",
-    "zod"
+    "zod",
+    "typescript",
+    "flat-config"
   ],
-  "author": "Your Name",
+  "author": "Sarj",
   "license": "MIT",
   "devDependencies": {
-    "eslint": "^8.0.0",
-    "mocha": "^10.0.0"
+    "@types/eslint": "^9.6.0",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^9.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.0.0"
   },
   "peerDependencies": {
-    "eslint": ">=6.0.0"
+    "eslint": ">=9.0.0"
   },
   "engines": {
-    "node": ">=14.0.0"
-  }
+    "node": ">=18.0.0"
+  },
+  "packageManager": "yarn@4.12.0+sha512.f45ab632439a67f8bc759bf32ead036a1f413287b9042726b7cc4818b7b49e14e9423ba49b18f9e06ea4941c1ad062385b1d8760a8d5091a1a31e5f6219afca8"
 }

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npx eslint:*)",
-      "Bash(rm:*)"
-    ],
-    "deny": []
-  }
-}

package/lib/index.js

@@ -1,19 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,44 +0,0 @@
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Enforce Zod schemas to be named with a Z prefix",
-      category: "Stylistic Issues",
-      recommended: false
-    },
-    fixable: null,
-    schema: []
-  },
-  create(context) {
-    return {
-      VariableDeclarator(node) {
-        // Check if the right side involves z.object() or other Zod schema creation
-        if (
-          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 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")
-          )
-        ) {
-          const variableName = node.id.name;
-          if (!variableName.startsWith("Z")) {
-            context.report({
-              node: node.id,
-              message: "Zod schema names should start with Z",
-            });
-          }
-        }
-      },
-    };
-  },
-};