@sarj/eslint-plugin 0.2.1 → 1.0.1

package/README.md

@@ -1,9 +1,138 @@
-# sarj-eslint
+# @sarj/eslint-plugin
 
-Collection of custom ESLint rules.
+Custom ESLint rules collection for Sarj projects. Supports ESLint 9+ flat config format.
 
 ## Installation
 
 ```bash
-npm install sarj-eslint --save-dev
+yarn add -D @sarj/eslint-plugin eslint
 ```
+
+## Usage (ESLint 9+ Flat Config)
+
+```js
+// eslint.config.js
+import sarj, { configs } from "@sarj/eslint-plugin";
+
+export default [
+  // Use a preset config
+  ...configs.recommended,
+
+  // Or configure manually
+  {
+    plugins: {
+      "@sarj": sarj,
+    },
+    rules: {
+      "@sarj/zod-naming-convention": "warn",
+      "@sarj/require-assert-never": "error",
+    },
+  },
+];
+```
+
+## Available Configs
+
+| Config | Description |
+|--------|-------------|
+| `configs.recommended` | Basic sarj rules for everyday use |
+| `configs.strict` | All sarj rules at error level |
+| `configs.style-guide` | Comprehensive rules (sarj + core ESLint) |
+
+## Rules
+
+| Rule | Description | Recommended |
+|------|-------------|-------------|
+| `@sarj/zod-naming-convention` | Enforce Zod schemas to be named with a Z prefix | warn |
+| `@sarj/require-assert-never` | Require assertNever in switch default cases | error |
+| `@sarj/require-zod-form-validation` | Require Zod validation when parsing FormData | error |
+| `@sarj/enforce-file-structure` | Enforce consistent file structure | warn |
+| `@sarj/no-raw-env` | Disallow direct process.env access | - |
+| `@sarj/prefer-shadcn` | Prefer shadcn/ui components over native HTML | - |
+| `@sarj/no-enum` | Disallow TypeScript enums | - |
+
+## Rule Details
+
+### `zod-naming-convention`
+
+Ensures Zod schemas are named with a Z prefix for consistency.
+
+```ts
+// Bad
+const userSchema = z.object({ name: z.string() });
+
+// Good
+const ZUserSchema = z.object({ name: z.string() });
+```
+
+### `require-assert-never`
+
+Ensures switch statements with default cases use assertNever for exhaustive type checking.
+
+```ts
+// Bad
+switch (status) {
+  case "active":
+    return 1;
+  default:
+    return 0;
+}
+
+// Good
+switch (status) {
+  case "active":
+    return 1;
+  default:
+    assertNever(status);
+}
+```
+
+### `no-raw-env`
+
+Disallows direct access to process.env. Use a Zod-validated env schema instead.
+
+```ts
+// Bad
+const apiKey = process.env.API_KEY;
+
+// Good
+const apiKey = env.API_KEY; // from validated schema
+```
+
+### `prefer-shadcn`
+
+Encourages use of shadcn/ui components instead of native HTML elements.
+
+```tsx
+// Bad
+<button onClick={handleClick}>Submit</button>
+
+// Good
+<Button onClick={handleClick}>Submit</Button>
+```
+
+### `no-enum`
+
+Discourages TypeScript enums in favor of union types or const objects.
+
+```ts
+// Bad
+enum Status {
+  Active,
+  Inactive,
+}
+
+// Good
+type Status = "active" | "inactive";
+// or
+const Status = { ACTIVE: "active", INACTIVE: "inactive" } as const;
+```
+
+## Requirements
+
+- ESLint >= 9.0.0
+- Node.js >= 18.0.0
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { ESLint, Linter, Rule } from "eslint";
+/**
+ * @sarj/eslint-plugin
+ *
+ * Custom ESLint rules collection for Sarj projects.
+ * Supports ESLint 9+ flat config format.
+ */
+declare const rules: Record<string, Rule.RuleModule>;
+declare const plugin: ESLint.Plugin;
+declare const configs: Record<string, Linter.Config[]>;
+export { plugin as default, configs, rules };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAUnD;;;;;GAKG;AAEH,QAAA,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAQ1C,CAAC;AAEF,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,MAMpB,CAAC;AAGF,QAAA,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAsE5C,CAAC;AAEF,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,98 @@
+import { zodNamingConvention } from "./rules/zod-naming-convention.js";
+import { requireAssertNever } from "./rules/require-assert-never.js";
+import { requireZodFormValidation } from "./rules/require-zod-form-validation.js";
+import { enforceFileStructure } from "./rules/enforce-file-structure.js";
+import { noRawEnv } from "./rules/no-raw-env.js";
+import { preferShadcn } from "./rules/prefer-shadcn.js";
+import { noEnum } from "./rules/no-enum.js";
+/**
+ * @sarj/eslint-plugin
+ *
+ * Custom ESLint rules collection for Sarj projects.
+ * Supports ESLint 9+ flat config format.
+ */
+const rules = {
+    "zod-naming-convention": zodNamingConvention,
+    "require-assert-never": requireAssertNever,
+    "require-zod-form-validation": requireZodFormValidation,
+    "enforce-file-structure": enforceFileStructure,
+    "no-raw-env": noRawEnv,
+    "prefer-shadcn": preferShadcn,
+    "no-enum": noEnum,
+};
+const plugin = {
+    meta: {
+        name: "@sarj/eslint-plugin",
+        version: "1.0.0",
+    },
+    rules,
+};
+// ESLint 9 flat configs
+const configs = {
+    // Basic sarj rules only
+    recommended: [
+        {
+            plugins: {
+                "@sarj": plugin,
+            },
+            rules: {
+                "@sarj/zod-naming-convention": "warn",
+                "@sarj/require-assert-never": "error",
+                "@sarj/require-zod-form-validation": "error",
+                "@sarj/enforce-file-structure": "warn",
+            },
+        },
+    ],
+    // All sarj rules at error level
+    strict: [
+        {
+            plugins: {
+                "@sarj": plugin,
+            },
+            rules: {
+                "@sarj/zod-naming-convention": "error",
+                "@sarj/require-assert-never": "error",
+                "@sarj/require-zod-form-validation": "error",
+                "@sarj/enforce-file-structure": "error",
+                "@sarj/no-raw-env": "error",
+                "@sarj/prefer-shadcn": "error",
+                "@sarj/no-enum": "error",
+            },
+        },
+    ],
+    // Comprehensive style guide rules (sarj + external)
+    "style-guide": [
+        {
+            plugins: {
+                "@sarj": plugin,
+            },
+            rules: {
+                // === Sarj custom rules ===
+                "@sarj/zod-naming-convention": "error",
+                "@sarj/require-assert-never": "error",
+                "@sarj/require-zod-form-validation": "error",
+                "@sarj/enforce-file-structure": "error",
+                "@sarj/no-raw-env": "error",
+                "@sarj/prefer-shadcn": "error",
+                "@sarj/no-enum": "error",
+                // === Core ESLint rules ===
+                "no-var": "error",
+                "prefer-const": "error",
+                "object-shorthand": ["error", "always"],
+                "no-nested-ternary": "error",
+                "no-console": ["warn", { allow: ["warn", "error"] }],
+                eqeqeq: ["error", "always"],
+                "no-param-reassign": "error",
+                "no-return-await": "error",
+                "prefer-template": "error",
+                "array-callback-return": "error",
+                // === Complexity limits ===
+                complexity: ["warn", { max: 15 }],
+                "max-depth": ["warn", { max: 4 }],
+                "max-nested-callbacks": ["warn", { max: 3 }],
+                "max-params": ["error", { max: 5 }],
+            },
+        },
+    ],
+};
+export { plugin as default, configs, rules };

package/dist/rules/enforce-file-structure.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+export declare const enforceFileStructure: Rule.RuleModule;
+export default enforceFileStructure;
+//# sourceMappingURL=enforce-file-structure.d.ts.map

package/dist/rules/enforce-file-structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-file-structure.d.ts","sourceRoot":"","sources":["../../src/rules/enforce-file-structure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAgDnC,eAAO,MAAM,oBAAoB,EAAE,IAAI,CAAC,UA8DvC,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

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

@@ -0,0 +1,90 @@
+/**
+ * @fileoverview Enforce consistent file structure
+ * @description Enforces: imports -> types -> constants -> functions -> exports
+ */
+const SECTIONS = ["imports", "types", "constants", "functions", "exports"];
+function getStatementSection(statement) {
+    const type = statement.type;
+    switch (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)
+            const varDecl = statement;
+            if (varDecl.kind === "const") {
+                const declarator = varDecl.declarations[0];
+                if (declarator?.id.type === "Identifier" &&
+                    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
+    }
+}
+export const enforceFileStructure = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Enforce consistent file structure: imports -> types -> constants -> functions -> exports",
+            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.filename;
+        const isServerAction = filename.includes("/actions/") || filename.includes("action");
+        return {
+            Program(node) {
+                const program = node;
+                const body = program.body;
+                let currentSection = 0;
+                // 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,
+                            messageId: "useServerDirective",
+                        });
+                    }
+                }
+                for (const statement of body) {
+                    const 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);
+                    }
+                }
+            },
+        };
+    },
+};
+export default enforceFileStructure;

package/dist/rules/no-enum.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from "eslint";
+/**
+ * @fileoverview Disallow TypeScript enums, prefer union types
+ * @description Enums add runtime code and have unintuitive behavior. Use union types instead.
+ */
+export declare const noEnum: Rule.RuleModule;
+export default noEnum;
+//# sourceMappingURL=no-enum.d.ts.map

package/dist/rules/no-enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-enum.d.ts","sourceRoot":"","sources":["../../src/rules/no-enum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;;GAGG;AAEH,eAAO,MAAM,MAAM,EAAE,IAAI,CAAC,UAyBzB,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/rules/no-enum.js

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Disallow TypeScript enums, prefer union types
+ * @description Enums add runtime code and have unintuitive behavior. Use union types instead.
+ */
+export const noEnum = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Disallow TypeScript enums, prefer union types or const objects",
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            noEnum: 'Enums are discouraged. Use union types (\'type Status = "active" | "inactive"\') or const objects instead.',
+        },
+    },
+    create(context) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            TSEnumDeclaration(node) {
+                context.report({
+                    node,
+                    messageId: "noEnum",
+                });
+            },
+        };
+    },
+};
+export default noEnum;

package/dist/rules/no-raw-env.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from "eslint";
+/**
+ * @fileoverview Disallow direct process.env access
+ * @description Use Zod-validated env schema instead of process.env
+ */
+export declare const noRawEnv: Rule.RuleModule;
+export default noRawEnv;
+//# sourceMappingURL=no-raw-env.d.ts.map

package/dist/rules/no-raw-env.d.ts.map

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

package/dist/rules/no-raw-env.js

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Disallow direct process.env access
+ * @description Use Zod-validated env schema instead of process.env
+ */
+export const noRawEnv = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow direct process.env access",
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            noRawEnv: "Use Zod-validated env schema instead of process.env directly",
+        },
+    },
+    create(context) {
+        return {
+            MemberExpression(node) {
+                if (node.object.type === "Identifier" &&
+                    node.object.name === "process" &&
+                    node.property.type === "Identifier" &&
+                    node.property.name === "env") {
+                    context.report({
+                        node,
+                        messageId: "noRawEnv",
+                    });
+                }
+            },
+        };
+    },
+};
+export default noRawEnv;

package/dist/rules/prefer-shadcn.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+export declare const preferShadcn: Rule.RuleModule;
+export default preferShadcn;
+//# sourceMappingURL=prefer-shadcn.d.ts.map

package/dist/rules/prefer-shadcn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-shadcn.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-shadcn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAgBnC,eAAO,MAAM,YAAY,EAAE,IAAI,CAAC,UAwC/B,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/rules/prefer-shadcn.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Prefer shadcn/ui components over native HTML elements
+ * @description Use shadcn components for consistent design system
+ */
+const REPLACEMENTS = {
+    button: "Button",
+    input: "Input",
+    select: "Select",
+    textarea: "Textarea",
+    table: "Table",
+    dialog: "Dialog",
+};
+export const preferShadcn = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Prefer shadcn/ui components over native HTML elements",
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            preferShadcn: "Use shadcn <{{replacement}}> component from @/components/ui/{{lowercase}} instead of native <{{element}}>",
+        },
+    },
+    create(context) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            JSXOpeningElement(node) {
+                // Only check lowercase element names (native HTML)
+                if (!node.name || node.name.type !== "JSXIdentifier") {
+                    return;
+                }
+                const elementName = node.name.name;
+                const replacement = REPLACEMENTS[elementName];
+                if (replacement) {
+                    context.report({
+                        node,
+                        messageId: "preferShadcn",
+                        data: {
+                            element: elementName,
+                            replacement,
+                            lowercase: elementName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};
+export default preferShadcn;

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-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/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.1",
+  "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 -p tsconfig.build.json",
+    "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",
-            });
-          }
-        }
-      },
-    };
-  },
-};