eslint-plugin-zod-utils 1.0.1 → 1.0.3

package/README.md

@@ -49,7 +49,7 @@ Legacy eslintrc:
 
 ### `zod-utils/no-inline-zod-schema`
 
-Requires Zod schemas to be created as module-level variable declarations. This avoids recreating schemas inside functions, callbacks, render paths, hooks, or argument lists.
+Requires Zod schemas to be created during module initialization. This avoids recreating schemas inside functions, callbacks, render paths, hooks, or instance fields.
 
 This rule was inspired by the motivation behind [`babel-plugin-zod-hoist`](https://github.com/gajus/babel-plugin-zod-hoist#motivation), which documents the cost of repeatedly initializing equivalent Zod schemas and the benefits of hoisting them.
 
@@ -70,10 +70,10 @@ function parseUser(input: unknown) {
 ```ts
 import { z } from "zod";
 
-app.post("/users", {
-  body: z.object({
+app.post("/users", (request) => {
+  return z.object({
     id: z.string(),
-  }),
+  }).parse(request.body);
 });
 ```
 
@@ -91,7 +91,38 @@ function parseUser(input: unknown) {
 }
 ```
 
+```ts
+import { z } from "zod";
+
+app.post("/users", {
+  body: z.object({
+    id: z.string(),
+  }),
+});
+```
+
 The rule understands `import { z } from "zod"`, `import * as zod from "zod"`, aliased `z` imports, and direct named schema factories such as `import { object, string } from "zod"`.
+It also understands default imports such as `import z from "zod"`.
+
+When type information is available through `@typescript-eslint/parser`, the rule also reports repeated derived schema creation from imported Zod schemas:
+
+```ts
+import { UserSchema } from "./schemas";
+
+function getPublicSchema() {
+  return UserSchema.pick({ id: true });
+}
+```
+
+```ts
+import { BaseSchema, TenantIdSchema } from "./schemas";
+
+function getTenantSchema() {
+  return BaseSchema.extend({ tenantId: TenantIdSchema });
+}
+```
+
+This type-aware detection does not use schema-name conventions. If type information is unavailable, imported schema roots are not inferred from names such as `UserSchema` or `UserZodSchema`. The rule also does not assume a global `z` identifier refers to Zod.
 
 ## Development
 

package/dist/index.cjs

@@ -88,6 +88,37 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "xid"
 ]);
 var ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["z", "coerce", "iso"]);
+var ZOD_EXECUTION_METHODS = /* @__PURE__ */ new Set([
+  "parse",
+  "parseAsync",
+  "safeParse",
+  "safeParseAsync"
+]);
+var ZOD_SCHEMA_COMBINATOR_METHODS = /* @__PURE__ */ new Set([
+  "and",
+  "array",
+  "brand",
+  "catchall",
+  "deepPartial",
+  "describe",
+  "extend",
+  "merge",
+  "nullable",
+  "nullish",
+  "omit",
+  "optional",
+  "or",
+  "partial",
+  "passthrough",
+  "pick",
+  "readonly",
+  "refine",
+  "required",
+  "strict",
+  "strip",
+  "superRefine",
+  "transform"
+]);
 function findVariable(scope, name) {
   let currentScope = scope;
   while (currentScope) {
@@ -121,8 +152,33 @@ function getRootIdentifier(node) {
       return null;
   }
 }
+function getRootMethodName(node) {
+  let current = node;
+  let rootMethodName = null;
+  while (true) {
+    if (current.type === "CallExpression") {
+      current = current.callee;
+      continue;
+    }
+    if (current.type === "MemberExpression") {
+      if (current.object.type === "Identifier" && !current.computed && current.property.type === "Identifier") {
+        rootMethodName = current.property.name;
+      }
+      current = current.object;
+      continue;
+    }
+    return rootMethodName;
+  }
+}
+function getCallMethodName(node) {
+  const { callee } = node;
+  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
+    return callee.property.name;
+  }
+  return null;
+}
 function isZodImportSpecifier(node) {
-  if (node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
+  if (node.type !== "ImportDefaultSpecifier" && node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
     return false;
   }
   const declaration = node.parent;
@@ -132,7 +188,7 @@ function isZodImportSpecifier(node) {
   if (declaration.source.value !== "zod") {
     return false;
   }
-  if (node.type === "ImportNamespaceSpecifier") {
+  if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") {
     return true;
   }
   if (node.importKind === "type" || declaration.importKind === "type") {
@@ -141,27 +197,38 @@ function isZodImportSpecifier(node) {
   const importedName = node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
   return ZOD_NAMESPACE_IMPORTS.has(importedName) || ZOD_FACTORY_IMPORTS.has(importedName);
 }
-function unwrapExpression(node) {
-  let current = node;
-  while (current.parent?.type === "TSAsExpression" || current.parent?.type === "TSNonNullExpression" || current.parent?.type === "TSSatisfiesExpression" || current.parent?.type === "TSTypeAssertion") {
-    current = current.parent;
-  }
-  return current;
+function hasFullTypeInformation(services) {
+  return services.program !== null;
+}
+function isZodDeclarationFile(fileName) {
+  return /(?:^|[/\\])node_modules[/\\]zod[/\\]/u.test(fileName);
 }
-function isModuleLevelVariableInitializer(node) {
-  const expression = unwrapExpression(node);
-  if (expression.parent?.type !== "VariableDeclarator") {
+function isZodSchemaType(type, services, seen = /* @__PURE__ */ new Set()) {
+  if (!hasFullTypeInformation(services)) {
     return false;
   }
-  if (expression.parent.init !== expression) {
+  if (seen.has(type)) {
     return false;
   }
-  const declaration = expression.parent.parent;
-  if (declaration.type !== "VariableDeclaration") {
-    return false;
+  seen.add(type);
+  const symbols = [type.getSymbol(), type.aliasSymbol];
+  if (symbols.some(
+    (symbol) => symbol?.getDeclarations()?.some(
+      (declaration) => isZodDeclarationFile(declaration.getSourceFile().fileName)
+    )
+  )) {
+    return true;
+  }
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((subType) => isZodSchemaType(subType, services, seen));
   }
-  const container = declaration.parent;
-  return container.type === "Program" || container.type === "ExportNamedDeclaration" && container.parent.type === "Program";
+  if (type.getBaseTypes()?.some((baseType) => isZodSchemaType(baseType, services, seen))) {
+    return true;
+  }
+  const parseSymbol = type.getProperty("parse");
+  return parseSymbol?.getDeclarations()?.some(
+    (declaration) => isZodDeclarationFile(declaration.getSourceFile().fileName)
+  ) ?? false;
 }
 var noInlineZodSchema = import_utils.ESLintUtils.RuleCreator(
   (ruleName2) => `https://www.npmjs.com/package/eslint-plugin-zod-utils#${ruleName2}`
@@ -173,14 +240,22 @@ var noInlineZodSchema = import_utils.ESLintUtils.RuleCreator(
       description: "Disallow creating Zod schemas outside module scope."
     },
     messages: {
-      inlineSchema: "Create Zod schemas at module scope instead of inline inside functions, callbacks, classes, or arguments."
+      inlineSchema: "Create Zod schemas during module initialization instead of inside functions, callbacks, or other repeated execution paths."
     },
     schema: []
   },
   defaultOptions: [],
   create(context) {
     const sourceCode = context.sourceCode;
+    const parserServices = import_utils.ESLintUtils.getParserServices(context, true);
+    function isZodExecutionCall(node) {
+      const methodName = getCallMethodName(node);
+      return methodName !== null && ZOD_EXECUTION_METHODS.has(methodName);
+    }
     function isZodSchemaCall(node) {
+      if (isZodExecutionCall(node)) {
+        return false;
+      }
       const root = getRootIdentifier(node.callee);
       if (!root) {
         return false;
@@ -189,10 +264,41 @@ var noInlineZodSchema = import_utils.ESLintUtils.RuleCreator(
       const variable = findVariable(scope, root.name);
       return variable?.defs.some((definition) => isZodImportSpecifier(definition.node)) ?? false;
     }
-    function hasZodCallAncestor(node) {
+    function isTypedZodSchemaCombinatorCall(node) {
+      const rootMethodName = getRootMethodName(node);
+      if (rootMethodName === null || !ZOD_SCHEMA_COMBINATOR_METHODS.has(rootMethodName)) {
+        return false;
+      }
+      const root = getRootIdentifier(node.callee);
+      if (!root) {
+        return false;
+      }
+      if (!hasFullTypeInformation(parserServices)) {
+        return false;
+      }
+      const type = parserServices.getTypeAtLocation(root);
+      return isZodSchemaType(type, parserServices);
+    }
+    function isSchemaCreationCall(node) {
+      return isZodSchemaCall(node) || isTypedZodSchemaCombinatorCall(node);
+    }
+    function hasSchemaCreationCallAncestor(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === "CallExpression" && isZodSchemaCall(current)) {
+        if (current.type === "CallExpression" && isSchemaCreationCall(current)) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+    function isInsideRepeatedExecutionPath(node) {
+      let current = node.parent;
+      while (current) {
+        if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+          return true;
+        }
+        if (current.type === "PropertyDefinition" && !current.static) {
           return true;
         }
         current = current.parent;
@@ -201,13 +307,13 @@ var noInlineZodSchema = import_utils.ESLintUtils.RuleCreator(
     }
     return {
       CallExpression(node) {
-        if (!isZodSchemaCall(node)) {
+        if (!isSchemaCreationCall(node)) {
           return;
         }
-        if (hasZodCallAncestor(node)) {
+        if (hasSchemaCreationCallAncestor(node)) {
           return;
         }
-        if (isModuleLevelVariableInitializer(node)) {
+        if (!isInsideRepeatedExecutionPath(node)) {
           return;
         }
         context.report({
@@ -227,7 +333,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "eslint-plugin-zod-utils",
-    version: "0.1.0"
+    version: "1.0.3"
   },
   rules,
   configs: {}

package/dist/index.js

@@ -60,6 +60,37 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "xid"
 ]);
 var ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["z", "coerce", "iso"]);
+var ZOD_EXECUTION_METHODS = /* @__PURE__ */ new Set([
+  "parse",
+  "parseAsync",
+  "safeParse",
+  "safeParseAsync"
+]);
+var ZOD_SCHEMA_COMBINATOR_METHODS = /* @__PURE__ */ new Set([
+  "and",
+  "array",
+  "brand",
+  "catchall",
+  "deepPartial",
+  "describe",
+  "extend",
+  "merge",
+  "nullable",
+  "nullish",
+  "omit",
+  "optional",
+  "or",
+  "partial",
+  "passthrough",
+  "pick",
+  "readonly",
+  "refine",
+  "required",
+  "strict",
+  "strip",
+  "superRefine",
+  "transform"
+]);
 function findVariable(scope, name) {
   let currentScope = scope;
   while (currentScope) {
@@ -93,8 +124,33 @@ function getRootIdentifier(node) {
       return null;
   }
 }
+function getRootMethodName(node) {
+  let current = node;
+  let rootMethodName = null;
+  while (true) {
+    if (current.type === "CallExpression") {
+      current = current.callee;
+      continue;
+    }
+    if (current.type === "MemberExpression") {
+      if (current.object.type === "Identifier" && !current.computed && current.property.type === "Identifier") {
+        rootMethodName = current.property.name;
+      }
+      current = current.object;
+      continue;
+    }
+    return rootMethodName;
+  }
+}
+function getCallMethodName(node) {
+  const { callee } = node;
+  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
+    return callee.property.name;
+  }
+  return null;
+}
 function isZodImportSpecifier(node) {
-  if (node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
+  if (node.type !== "ImportDefaultSpecifier" && node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
     return false;
   }
   const declaration = node.parent;
@@ -104,7 +160,7 @@ function isZodImportSpecifier(node) {
   if (declaration.source.value !== "zod") {
     return false;
   }
-  if (node.type === "ImportNamespaceSpecifier") {
+  if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") {
     return true;
   }
   if (node.importKind === "type" || declaration.importKind === "type") {
@@ -113,27 +169,38 @@ function isZodImportSpecifier(node) {
   const importedName = node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
   return ZOD_NAMESPACE_IMPORTS.has(importedName) || ZOD_FACTORY_IMPORTS.has(importedName);
 }
-function unwrapExpression(node) {
-  let current = node;
-  while (current.parent?.type === "TSAsExpression" || current.parent?.type === "TSNonNullExpression" || current.parent?.type === "TSSatisfiesExpression" || current.parent?.type === "TSTypeAssertion") {
-    current = current.parent;
-  }
-  return current;
+function hasFullTypeInformation(services) {
+  return services.program !== null;
+}
+function isZodDeclarationFile(fileName) {
+  return /(?:^|[/\\])node_modules[/\\]zod[/\\]/u.test(fileName);
 }
-function isModuleLevelVariableInitializer(node) {
-  const expression = unwrapExpression(node);
-  if (expression.parent?.type !== "VariableDeclarator") {
+function isZodSchemaType(type, services, seen = /* @__PURE__ */ new Set()) {
+  if (!hasFullTypeInformation(services)) {
     return false;
   }
-  if (expression.parent.init !== expression) {
+  if (seen.has(type)) {
     return false;
   }
-  const declaration = expression.parent.parent;
-  if (declaration.type !== "VariableDeclaration") {
-    return false;
+  seen.add(type);
+  const symbols = [type.getSymbol(), type.aliasSymbol];
+  if (symbols.some(
+    (symbol) => symbol?.getDeclarations()?.some(
+      (declaration) => isZodDeclarationFile(declaration.getSourceFile().fileName)
+    )
+  )) {
+    return true;
+  }
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((subType) => isZodSchemaType(subType, services, seen));
   }
-  const container = declaration.parent;
-  return container.type === "Program" || container.type === "ExportNamedDeclaration" && container.parent.type === "Program";
+  if (type.getBaseTypes()?.some((baseType) => isZodSchemaType(baseType, services, seen))) {
+    return true;
+  }
+  const parseSymbol = type.getProperty("parse");
+  return parseSymbol?.getDeclarations()?.some(
+    (declaration) => isZodDeclarationFile(declaration.getSourceFile().fileName)
+  ) ?? false;
 }
 var noInlineZodSchema = ESLintUtils.RuleCreator(
   (ruleName2) => `https://www.npmjs.com/package/eslint-plugin-zod-utils#${ruleName2}`
@@ -145,14 +212,22 @@ var noInlineZodSchema = ESLintUtils.RuleCreator(
       description: "Disallow creating Zod schemas outside module scope."
     },
     messages: {
-      inlineSchema: "Create Zod schemas at module scope instead of inline inside functions, callbacks, classes, or arguments."
+      inlineSchema: "Create Zod schemas during module initialization instead of inside functions, callbacks, or other repeated execution paths."
     },
     schema: []
   },
   defaultOptions: [],
   create(context) {
     const sourceCode = context.sourceCode;
+    const parserServices = ESLintUtils.getParserServices(context, true);
+    function isZodExecutionCall(node) {
+      const methodName = getCallMethodName(node);
+      return methodName !== null && ZOD_EXECUTION_METHODS.has(methodName);
+    }
     function isZodSchemaCall(node) {
+      if (isZodExecutionCall(node)) {
+        return false;
+      }
       const root = getRootIdentifier(node.callee);
       if (!root) {
         return false;
@@ -161,10 +236,41 @@ var noInlineZodSchema = ESLintUtils.RuleCreator(
       const variable = findVariable(scope, root.name);
       return variable?.defs.some((definition) => isZodImportSpecifier(definition.node)) ?? false;
     }
-    function hasZodCallAncestor(node) {
+    function isTypedZodSchemaCombinatorCall(node) {
+      const rootMethodName = getRootMethodName(node);
+      if (rootMethodName === null || !ZOD_SCHEMA_COMBINATOR_METHODS.has(rootMethodName)) {
+        return false;
+      }
+      const root = getRootIdentifier(node.callee);
+      if (!root) {
+        return false;
+      }
+      if (!hasFullTypeInformation(parserServices)) {
+        return false;
+      }
+      const type = parserServices.getTypeAtLocation(root);
+      return isZodSchemaType(type, parserServices);
+    }
+    function isSchemaCreationCall(node) {
+      return isZodSchemaCall(node) || isTypedZodSchemaCombinatorCall(node);
+    }
+    function hasSchemaCreationCallAncestor(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === "CallExpression" && isZodSchemaCall(current)) {
+        if (current.type === "CallExpression" && isSchemaCreationCall(current)) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+    function isInsideRepeatedExecutionPath(node) {
+      let current = node.parent;
+      while (current) {
+        if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+          return true;
+        }
+        if (current.type === "PropertyDefinition" && !current.static) {
           return true;
         }
         current = current.parent;
@@ -173,13 +279,13 @@ var noInlineZodSchema = ESLintUtils.RuleCreator(
     }
     return {
       CallExpression(node) {
-        if (!isZodSchemaCall(node)) {
+        if (!isSchemaCreationCall(node)) {
           return;
         }
-        if (hasZodCallAncestor(node)) {
+        if (hasSchemaCreationCallAncestor(node)) {
           return;
         }
-        if (isModuleLevelVariableInitializer(node)) {
+        if (!isInsideRepeatedExecutionPath(node)) {
           return;
         }
         context.report({
@@ -199,7 +305,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "eslint-plugin-zod-utils",
-    version: "0.1.0"
+    version: "1.0.3"
   },
   rules,
   configs: {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod-utils",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "ESLint utilities for safer Zod schema usage.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -46,7 +46,8 @@
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.60.1",
-    "vitest": "^4.1.8"
+    "vitest": "^4.1.8",
+    "zod": "^4.4.3"
   },
   "dependencies": {
     "@typescript-eslint/utils": "^8.60.1"