eslint-plugin-zod-utils 1.0.2 → 1.0.4

package/README.md

@@ -102,6 +102,27 @@ app.post("/users", {
 ```
 
 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

@@ -48,6 +48,7 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "enum",
   "file",
   "function",
+  "fromJSONSchema",
   "instanceof",
   "intersection",
   "ipv4",
@@ -56,6 +57,7 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "ksuid",
   "lazy",
   "literal",
+  "looseObject",
   "map",
   "nan",
   "nanoid",
@@ -72,6 +74,7 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "set",
   "string",
   "stringbool",
+  "strictObject",
   "symbol",
   "templateLiteral",
   "tuple",
@@ -88,6 +91,38 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "xid"
 ]);
 var ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["z", "coerce", "iso"]);
+var ZOD_ISO_FACTORY_IMPORTS = /* @__PURE__ */ new Set(["date", "datetime", "duration", "time"]);
+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,25 +156,131 @@ function getRootIdentifier(node) {
       return null;
   }
 }
-function isZodImportSpecifier(node) {
-  if (node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
-    return false;
+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 getMemberPathFromRoot(node) {
+  const memberPath = [];
+  let current = node;
+  while (true) {
+    if (current.type === "CallExpression") {
+      current = current.callee;
+      continue;
+    }
+    if (current.type === "ChainExpression") {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion") {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === "MemberExpression") {
+      if (current.computed || current.property.type !== "Identifier") {
+        return null;
+      }
+      memberPath.unshift(current.property.name);
+      current = current.object;
+      continue;
+    }
+    return memberPath;
+  }
+}
+function getCallMethodName(node) {
+  const { callee } = node;
+  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
+    return callee.property.name;
+  }
+  return null;
+}
+function getZodImportKind(node) {
+  if (node.type !== "ImportDefaultSpecifier" && node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
+    return null;
   }
   const declaration = node.parent;
   if (declaration?.type !== "ImportDeclaration") {
-    return false;
+    return null;
   }
   if (declaration.source.value !== "zod") {
-    return false;
+    return null;
   }
-  if (node.type === "ImportNamespaceSpecifier") {
-    return true;
+  if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") {
+    return { importedName: "z", type: "namespace" };
   }
   if (node.importKind === "type" || declaration.importKind === "type") {
-    return false;
+    return null;
   }
   const importedName = node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
-  return ZOD_NAMESPACE_IMPORTS.has(importedName) || ZOD_FACTORY_IMPORTS.has(importedName);
+  if (ZOD_NAMESPACE_IMPORTS.has(importedName)) {
+    return { importedName, type: "namespace" };
+  }
+  if (ZOD_FACTORY_IMPORTS.has(importedName)) {
+    return { type: "factory" };
+  }
+  return null;
+}
+function isZodSchemaNamespaceCall(importName, memberPath) {
+  if (importName === "coerce") {
+    return memberPath[0] !== void 0 && ZOD_FACTORY_IMPORTS.has(memberPath[0]);
+  }
+  if (importName === "iso") {
+    return memberPath[0] !== void 0 && ZOD_ISO_FACTORY_IMPORTS.has(memberPath[0]);
+  }
+  if (memberPath[0] === "coerce") {
+    return memberPath[1] !== void 0 && ZOD_FACTORY_IMPORTS.has(memberPath[1]);
+  }
+  if (memberPath[0] === "iso") {
+    return memberPath[1] !== void 0 && ZOD_ISO_FACTORY_IMPORTS.has(memberPath[1]);
+  }
+  return memberPath[0] !== void 0 && ZOD_FACTORY_IMPORTS.has(memberPath[0]);
+}
+function hasFullTypeInformation(services) {
+  return services.program !== null;
+}
+function isZodDeclarationFile(fileName) {
+  return /(?:^|[/\\])node_modules[/\\]zod[/\\]/u.test(fileName);
+}
+function isZodSchemaType(type, services, seen = /* @__PURE__ */ new Set()) {
+  if (!hasFullTypeInformation(services)) {
+    return false;
+  }
+  if (seen.has(type)) {
+    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));
+  }
+  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}`
@@ -158,19 +299,58 @@ var noInlineZodSchema = import_utils.ESLintUtils.RuleCreator(
   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;
       }
       const scope = sourceCode.getScope(root);
       const variable = findVariable(scope, root.name);
-      return variable?.defs.some((definition) => isZodImportSpecifier(definition.node)) ?? false;
+      return variable?.defs.some((definition) => {
+        const importKind = getZodImportKind(definition.node);
+        if (importKind?.type === "factory") {
+          return true;
+        }
+        if (importKind?.type !== "namespace") {
+          return false;
+        }
+        const memberPath = getMemberPathFromRoot(node.callee);
+        if (memberPath === null || memberPath.length === 0) {
+          return false;
+        }
+        return isZodSchemaNamespaceCall(importKind.importedName, memberPath);
+      }) ?? false;
+    }
+    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 hasZodCallAncestor(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;
@@ -192,10 +372,10 @@ var noInlineZodSchema = import_utils.ESLintUtils.RuleCreator(
     }
     return {
       CallExpression(node) {
-        if (!isZodSchemaCall(node)) {
+        if (!isSchemaCreationCall(node)) {
           return;
         }
-        if (hasZodCallAncestor(node)) {
+        if (hasSchemaCreationCallAncestor(node)) {
           return;
         }
         if (!isInsideRepeatedExecutionPath(node)) {
@@ -218,7 +398,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "eslint-plugin-zod-utils",
-    version: "0.1.0"
+    version: "1.0.4"
   },
   rules,
   configs: {}

package/dist/index.js

@@ -20,6 +20,7 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "enum",
   "file",
   "function",
+  "fromJSONSchema",
   "instanceof",
   "intersection",
   "ipv4",
@@ -28,6 +29,7 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "ksuid",
   "lazy",
   "literal",
+  "looseObject",
   "map",
   "nan",
   "nanoid",
@@ -44,6 +46,7 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "set",
   "string",
   "stringbool",
+  "strictObject",
   "symbol",
   "templateLiteral",
   "tuple",
@@ -60,6 +63,38 @@ var ZOD_FACTORY_IMPORTS = /* @__PURE__ */ new Set([
   "xid"
 ]);
 var ZOD_NAMESPACE_IMPORTS = /* @__PURE__ */ new Set(["z", "coerce", "iso"]);
+var ZOD_ISO_FACTORY_IMPORTS = /* @__PURE__ */ new Set(["date", "datetime", "duration", "time"]);
+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,25 +128,131 @@ function getRootIdentifier(node) {
       return null;
   }
 }
-function isZodImportSpecifier(node) {
-  if (node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
-    return false;
+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 getMemberPathFromRoot(node) {
+  const memberPath = [];
+  let current = node;
+  while (true) {
+    if (current.type === "CallExpression") {
+      current = current.callee;
+      continue;
+    }
+    if (current.type === "ChainExpression") {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion") {
+      current = current.expression;
+      continue;
+    }
+    if (current.type === "MemberExpression") {
+      if (current.computed || current.property.type !== "Identifier") {
+        return null;
+      }
+      memberPath.unshift(current.property.name);
+      current = current.object;
+      continue;
+    }
+    return memberPath;
+  }
+}
+function getCallMethodName(node) {
+  const { callee } = node;
+  if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier") {
+    return callee.property.name;
+  }
+  return null;
+}
+function getZodImportKind(node) {
+  if (node.type !== "ImportDefaultSpecifier" && node.type !== "ImportNamespaceSpecifier" && node.type !== "ImportSpecifier") {
+    return null;
   }
   const declaration = node.parent;
   if (declaration?.type !== "ImportDeclaration") {
-    return false;
+    return null;
   }
   if (declaration.source.value !== "zod") {
-    return false;
+    return null;
   }
-  if (node.type === "ImportNamespaceSpecifier") {
-    return true;
+  if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") {
+    return { importedName: "z", type: "namespace" };
   }
   if (node.importKind === "type" || declaration.importKind === "type") {
-    return false;
+    return null;
   }
   const importedName = node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
-  return ZOD_NAMESPACE_IMPORTS.has(importedName) || ZOD_FACTORY_IMPORTS.has(importedName);
+  if (ZOD_NAMESPACE_IMPORTS.has(importedName)) {
+    return { importedName, type: "namespace" };
+  }
+  if (ZOD_FACTORY_IMPORTS.has(importedName)) {
+    return { type: "factory" };
+  }
+  return null;
+}
+function isZodSchemaNamespaceCall(importName, memberPath) {
+  if (importName === "coerce") {
+    return memberPath[0] !== void 0 && ZOD_FACTORY_IMPORTS.has(memberPath[0]);
+  }
+  if (importName === "iso") {
+    return memberPath[0] !== void 0 && ZOD_ISO_FACTORY_IMPORTS.has(memberPath[0]);
+  }
+  if (memberPath[0] === "coerce") {
+    return memberPath[1] !== void 0 && ZOD_FACTORY_IMPORTS.has(memberPath[1]);
+  }
+  if (memberPath[0] === "iso") {
+    return memberPath[1] !== void 0 && ZOD_ISO_FACTORY_IMPORTS.has(memberPath[1]);
+  }
+  return memberPath[0] !== void 0 && ZOD_FACTORY_IMPORTS.has(memberPath[0]);
+}
+function hasFullTypeInformation(services) {
+  return services.program !== null;
+}
+function isZodDeclarationFile(fileName) {
+  return /(?:^|[/\\])node_modules[/\\]zod[/\\]/u.test(fileName);
+}
+function isZodSchemaType(type, services, seen = /* @__PURE__ */ new Set()) {
+  if (!hasFullTypeInformation(services)) {
+    return false;
+  }
+  if (seen.has(type)) {
+    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));
+  }
+  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}`
@@ -130,19 +271,58 @@ var noInlineZodSchema = ESLintUtils.RuleCreator(
   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;
       }
       const scope = sourceCode.getScope(root);
       const variable = findVariable(scope, root.name);
-      return variable?.defs.some((definition) => isZodImportSpecifier(definition.node)) ?? false;
+      return variable?.defs.some((definition) => {
+        const importKind = getZodImportKind(definition.node);
+        if (importKind?.type === "factory") {
+          return true;
+        }
+        if (importKind?.type !== "namespace") {
+          return false;
+        }
+        const memberPath = getMemberPathFromRoot(node.callee);
+        if (memberPath === null || memberPath.length === 0) {
+          return false;
+        }
+        return isZodSchemaNamespaceCall(importKind.importedName, memberPath);
+      }) ?? false;
+    }
+    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 hasZodCallAncestor(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;
@@ -164,10 +344,10 @@ var noInlineZodSchema = ESLintUtils.RuleCreator(
     }
     return {
       CallExpression(node) {
-        if (!isZodSchemaCall(node)) {
+        if (!isSchemaCreationCall(node)) {
           return;
         }
-        if (hasZodCallAncestor(node)) {
+        if (hasSchemaCreationCallAncestor(node)) {
           return;
         }
         if (!isInsideRepeatedExecutionPath(node)) {
@@ -190,7 +370,7 @@ var rules = {
 var plugin = {
   meta: {
     name: "eslint-plugin-zod-utils",
-    version: "0.1.0"
+    version: "1.0.4"
   },
   rules,
   configs: {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod-utils",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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"