eslint-plugin-zod 4.2.2 → 4.4.0

package/README.md

@@ -50,13 +50,17 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [no-number-schema-with-safe](docs/rules/no-number-schema-with-safe.md)                           | Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`.                                | ✅  | 🔧  |     |     |
 | [no-number-schema-with-step](docs/rules/no-number-schema-with-step.md)                           | Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead.                                                          | ✅  | 🔧  |     |     |
 | [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md)               | Disallow using both `.optional()` and `.default()` on the same Zod schema                                                      | ✅  | 🔧  |     |     |
+| [no-schema-with-is-nullable](docs/rules/no-schema-with-is-nullable.md)                           | Disallow deprecated `.isNullable()` on a Zod schema; use `safeParse(null).success` instead.                                    | ✅  |     |     |     |
+| [no-schema-with-is-optional](docs/rules/no-schema-with-is-optional.md)                           | Disallow deprecated `.isOptional()` on a Zod schema; use `safeParse(undefined).success` instead.                               | ✅  |     |     |     |
 | [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)                           | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema                                              | ✅  | 🔧  |     | ❌  |
 | [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                                           | Disallow throwing errors directly inside Zod refine callbacks                                                                  | ✅  |     |     |     |
 | [no-transform-in-record-key](docs/rules/no-transform-in-record-key.md)                           | Disallow transforms in z.record() key schemas, which can cause silent key mutations and data loss through key collisions       |     |     |     |     |
 | [no-unknown-schema](docs/rules/no-unknown-schema.md)                                             | Disallow usage of `z.unknown()` in Zod schemas                                                                                 |     |     |     |     |
 | [prefer-enum-over-literal-union](docs/rules/prefer-enum-over-literal-union.md)                   | Prefer `z.enum()` over `z.union()` when all members are string literals.                                                       | ✅  | 🔧  |     |     |
+| [prefer-loose-object](docs/rules/prefer-loose-object.md)                                         | Prefer `z.looseObject()` over `z.object().passthrough()` and `z.object().loose()`                                              | ✅  | 🔧  |     |     |
 | [prefer-meta](docs/rules/prefer-meta.md)                                                         | Enforce usage of `.meta()` over `.describe()`                                                                                  | ✅  | 🔧  |     |     |
 | [prefer-meta-last](docs/rules/prefer-meta-last.md)                                               | Enforce `.meta()` as last method                                                                                               | ✅  | 🔧  |     |     |
+| [prefer-strict-object](docs/rules/prefer-strict-object.md)                                       | Prefer `z.strictObject()` over `z.object().strict()`                                                                           | ✅  | 🔧  |     |     |
 | [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)                   | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                                                  | ✅  | 🔧  |     |     |
 | [prefer-top-level-string-formats](docs/rules/prefer-top-level-string-formats.md)                 | Prefer top-level string format schemas over deprecated `z.string().<format>()` methods                                         | ✅  | 🔧  |     |     |
 | [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |     |
@@ -106,10 +110,7 @@ import { defineConfig } from 'eslint/config';
 import eslint from '@eslint/js';
 import eslintPluginZod from 'eslint-plugin-zod';
 
-export default defineConfig(
-  eslint.configs.recommended,
-  eslintPluginZod.configs.recommended,
-);
+export default defineConfig(eslint.configs.recommended, eslintPluginZod.configs.recommended);
 ```
 
 ### Oxlint

package/dist/index.cjs

@@ -15,13 +15,17 @@ const require_no_number_schema_with_is_int = require("./rules/no-number-schema-w
 const require_no_number_schema_with_safe = require("./rules/no-number-schema-with-safe.cjs");
 const require_no_number_schema_with_step = require("./rules/no-number-schema-with-step.cjs");
 const require_no_optional_and_default_together = require("./rules/no-optional-and-default-together.cjs");
+const require_no_schema_with_is_nullable = require("./rules/no-schema-with-is-nullable.cjs");
+const require_no_schema_with_is_optional = require("./rules/no-schema-with-is-optional.cjs");
 const require_no_string_schema_with_uuid = require("./rules/no-string-schema-with-uuid.cjs");
 const require_no_throw_in_refine = require("./rules/no-throw-in-refine.cjs");
 const require_no_transform_in_record_key = require("./rules/no-transform-in-record-key.cjs");
 const require_no_unknown_schema = require("./rules/no-unknown-schema.cjs");
 const require_prefer_enum_over_literal_union = require("./rules/prefer-enum-over-literal-union.cjs");
+const require_prefer_loose_object = require("./rules/prefer-loose-object.cjs");
 const require_prefer_meta_last = require("./rules/prefer-meta-last.cjs");
 const require_prefer_meta = require("./rules/prefer-meta.cjs");
+const require_prefer_strict_object = require("./rules/prefer-strict-object.cjs");
 const require_prefer_string_schema_with_trim = require("./rules/prefer-string-schema-with-trim.cjs");
 const require_prefer_top_level_string_formats = require("./rules/prefer-top-level-string-formats.cjs");
 const require_prefer_trim_before_string_length_checks = require("./rules/prefer-trim-before-string-length-checks.cjs");
@@ -52,12 +56,16 @@ const eslintPluginZod = {
 		"no-number-schema-with-step": require_no_number_schema_with_step.noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": require_no_string_schema_with_uuid.noStringSchemaWithUuid,
 		"no-optional-and-default-together": require_no_optional_and_default_together.noOptionalAndDefaultTogether,
+		"no-schema-with-is-nullable": require_no_schema_with_is_nullable.noSchemaWithIsNullable,
+		"no-schema-with-is-optional": require_no_schema_with_is_optional.noSchemaWithIsOptional,
 		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
 		"no-transform-in-record-key": require_no_transform_in_record_key.noTransformInRecordKey,
 		"no-unknown-schema": require_no_unknown_schema.noUnknownSchema,
 		"prefer-enum-over-literal-union": require_prefer_enum_over_literal_union.preferEnumOverLiteralUnion,
+		"prefer-loose-object": require_prefer_loose_object.preferLooseObject,
 		"prefer-meta": require_prefer_meta.preferMeta,
 		"prefer-meta-last": require_prefer_meta_last.preferMetaLast,
+		"prefer-strict-object": require_prefer_strict_object.preferStrictObject,
 		"prefer-top-level-string-formats": require_prefer_top_level_string_formats.preferTopLevelStringFormats,
 		"prefer-string-schema-with-trim": require_prefer_string_schema_with_trim.preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": require_prefer_trim_before_string_length_checks.preferTrimBeforeStringLengthChecks,
@@ -85,10 +93,14 @@ const recommendedConfig = {
 		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
+		"zod/no-schema-with-is-nullable": "error",
+		"zod/no-schema-with-is-optional": "error",
 		"zod/no-throw-in-refine": "error",
 		"zod/prefer-enum-over-literal-union": "error",
+		"zod/prefer-loose-object": "error",
 		"zod/prefer-meta": "error",
 		"zod/prefer-meta-last": "error",
+		"zod/prefer-strict-object": "error",
 		"zod/prefer-top-level-string-formats": "error",
 		"zod/prefer-string-schema-with-trim": "error",
 		"zod/prefer-trim-before-string-length-checks": "error",

package/dist/index.mjs

@@ -15,13 +15,17 @@ import { noNumberSchemaWithIsInt } from "./rules/no-number-schema-with-is-int.mj
 import { noNumberSchemaWithSafe } from "./rules/no-number-schema-with-safe.mjs";
 import { noNumberSchemaWithStep } from "./rules/no-number-schema-with-step.mjs";
 import { noOptionalAndDefaultTogether } from "./rules/no-optional-and-default-together.mjs";
+import { noSchemaWithIsNullable } from "./rules/no-schema-with-is-nullable.mjs";
+import { noSchemaWithIsOptional } from "./rules/no-schema-with-is-optional.mjs";
 import { noStringSchemaWithUuid } from "./rules/no-string-schema-with-uuid.mjs";
 import { noThrowInRefine } from "./rules/no-throw-in-refine.mjs";
 import { noTransformInRecordKey } from "./rules/no-transform-in-record-key.mjs";
 import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
 import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.mjs";
+import { preferLooseObject } from "./rules/prefer-loose-object.mjs";
 import { preferMetaLast } from "./rules/prefer-meta-last.mjs";
 import { preferMeta } from "./rules/prefer-meta.mjs";
+import { preferStrictObject } from "./rules/prefer-strict-object.mjs";
 import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-trim.mjs";
 import { preferTopLevelStringFormats } from "./rules/prefer-top-level-string-formats.mjs";
 import { preferTrimBeforeStringLengthChecks } from "./rules/prefer-trim-before-string-length-checks.mjs";
@@ -52,12 +56,16 @@ const eslintPluginZod = {
 		"no-number-schema-with-step": noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": noStringSchemaWithUuid,
 		"no-optional-and-default-together": noOptionalAndDefaultTogether,
+		"no-schema-with-is-nullable": noSchemaWithIsNullable,
+		"no-schema-with-is-optional": noSchemaWithIsOptional,
 		"no-throw-in-refine": noThrowInRefine,
 		"no-transform-in-record-key": noTransformInRecordKey,
 		"no-unknown-schema": noUnknownSchema,
 		"prefer-enum-over-literal-union": preferEnumOverLiteralUnion,
+		"prefer-loose-object": preferLooseObject,
 		"prefer-meta": preferMeta,
 		"prefer-meta-last": preferMetaLast,
+		"prefer-strict-object": preferStrictObject,
 		"prefer-top-level-string-formats": preferTopLevelStringFormats,
 		"prefer-string-schema-with-trim": preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": preferTrimBeforeStringLengthChecks,
@@ -85,10 +93,14 @@ const recommendedConfig = {
 		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
+		"zod/no-schema-with-is-nullable": "error",
+		"zod/no-schema-with-is-optional": "error",
 		"zod/no-throw-in-refine": "error",
 		"zod/prefer-enum-over-literal-union": "error",
+		"zod/prefer-loose-object": "error",
 		"zod/prefer-meta": "error",
 		"zod/prefer-meta-last": "error",
+		"zod/prefer-strict-object": "error",
 		"zod/prefer-top-level-string-formats": "error",
 		"zod/prefer-string-schema-with-trim": "error",
 		"zod/prefer-trim-before-string-length-checks": "error",

package/dist/rules/no-schema-with-is-nullable.cjs

@@ -0,0 +1,35 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/no-schema-with-is-nullable.ts
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const noSchemaWithIsNullable = require_create_plugin_rule.createZodPluginRule({
+	name: "no-schema-with-is-nullable",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `.isNullable()` on a Zod schema; use `safeParse(null).success` instead." },
+		messages: { useSafeParse: "`.isNullable()` is deprecated. Try `schema.safeParse(null).success` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { methods } = zodSchemaMeta;
+				const isNullableIndex = methods.findIndex((it) => it === "isNullable");
+				if (isNullableIndex === -1) return;
+				if (methods.slice(0, isNullableIndex).some((method) => _eslint_zod_utils.ZOD_NON_SCHEMA_PRODUCING_METHODS.includes(method))) return;
+				context.report({
+					node,
+					messageId: "useSafeParse"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noSchemaWithIsNullable = noSchemaWithIsNullable;

package/dist/rules/no-schema-with-is-nullable.mjs

@@ -0,0 +1,34 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { ZOD_NON_SCHEMA_PRODUCING_METHODS, createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+//#region src/rules/no-schema-with-is-nullable.ts
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const noSchemaWithIsNullable = createZodPluginRule({
+	name: "no-schema-with-is-nullable",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `.isNullable()` on a Zod schema; use `safeParse(null).success` instead." },
+		messages: { useSafeParse: "`.isNullable()` is deprecated. Try `schema.safeParse(null).success` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { methods } = zodSchemaMeta;
+				const isNullableIndex = methods.findIndex((it) => it === "isNullable");
+				if (isNullableIndex === -1) return;
+				if (methods.slice(0, isNullableIndex).some((method) => ZOD_NON_SCHEMA_PRODUCING_METHODS.includes(method))) return;
+				context.report({
+					node,
+					messageId: "useSafeParse"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noSchemaWithIsNullable };

package/dist/rules/no-schema-with-is-optional.cjs

@@ -0,0 +1,35 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/no-schema-with-is-optional.ts
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const noSchemaWithIsOptional = require_create_plugin_rule.createZodPluginRule({
+	name: "no-schema-with-is-optional",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `.isOptional()` on a Zod schema; use `safeParse(undefined).success` instead." },
+		messages: { useSafeParse: "`.isOptional()` is deprecated. Try `schema.safeParse(undefined).success` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { methods } = zodSchemaMeta;
+				const isOptionalIndex = methods.findIndex((it) => it === "isOptional");
+				if (isOptionalIndex === -1) return;
+				if (methods.slice(0, isOptionalIndex).some((method) => _eslint_zod_utils.ZOD_NON_SCHEMA_PRODUCING_METHODS.includes(method))) return;
+				context.report({
+					node,
+					messageId: "useSafeParse"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noSchemaWithIsOptional = noSchemaWithIsOptional;

package/dist/rules/no-schema-with-is-optional.mjs

@@ -0,0 +1,34 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { ZOD_NON_SCHEMA_PRODUCING_METHODS, createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+//#region src/rules/no-schema-with-is-optional.ts
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const noSchemaWithIsOptional = createZodPluginRule({
+	name: "no-schema-with-is-optional",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `.isOptional()` on a Zod schema; use `safeParse(undefined).success` instead." },
+		messages: { useSafeParse: "`.isOptional()` is deprecated. Try `schema.safeParse(undefined).success` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { methods } = zodSchemaMeta;
+				const isOptionalIndex = methods.findIndex((it) => it === "isOptional");
+				if (isOptionalIndex === -1) return;
+				if (methods.slice(0, isOptionalIndex).some((method) => ZOD_NON_SCHEMA_PRODUCING_METHODS.includes(method))) return;
+				context.report({
+					node,
+					messageId: "useSafeParse"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noSchemaWithIsOptional };

package/dist/rules/prefer-loose-object.cjs

@@ -0,0 +1,49 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/prefer-loose-object.ts
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const preferLooseObject = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-loose-object",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `z.looseObject()` over `z.object().passthrough()` and `z.object().loose()`" },
+		messages: { preferLooseObject: "Use `z.looseObject()` instead of `.passthrough()` or `.loose()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "object") return;
+				const methods = collectZodChainMethods(zodSchemaMeta.node);
+				const looseMethod = methods.find((it) => it.name === "passthrough" || it.name === "loose");
+				if (!looseMethod) return;
+				context.report({
+					node: looseMethod.node,
+					messageId: "preferLooseObject",
+					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
+						if (looseMethod.node.arguments.length !== 0) return null;
+						const objectMethod = methods.find((it) => it.name === "object");
+						if (!objectMethod) return null;
+						const { sourceCode } = context;
+						const replacementText = objectMethod.node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? `${sourceCode.getText(objectMethod.node.callee.object)}.looseObject` : "looseObject";
+						const fixes = [fixer.replaceText(objectMethod.node.callee, replacementText)];
+						const calleeProperty = looseMethod.node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? looseMethod.node.callee.property : looseMethod.node.callee;
+						const tokenBefore = sourceCode.getTokenBefore(calleeProperty);
+						if (tokenBefore?.value === ".") fixes.push(fixer.removeRange([tokenBefore.range[0], looseMethod.node.range[1]]));
+						return fixes;
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.preferLooseObject = preferLooseObject;

package/dist/rules/prefer-loose-object.mjs

@@ -0,0 +1,48 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/prefer-loose-object.ts
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const preferLooseObject = createZodPluginRule({
+	name: "prefer-loose-object",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `z.looseObject()` over `z.object().passthrough()` and `z.object().loose()`" },
+		messages: { preferLooseObject: "Use `z.looseObject()` instead of `.passthrough()` or `.loose()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "object") return;
+				const methods = collectZodChainMethods(zodSchemaMeta.node);
+				const looseMethod = methods.find((it) => it.name === "passthrough" || it.name === "loose");
+				if (!looseMethod) return;
+				context.report({
+					node: looseMethod.node,
+					messageId: "preferLooseObject",
+					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
+						if (looseMethod.node.arguments.length !== 0) return null;
+						const objectMethod = methods.find((it) => it.name === "object");
+						if (!objectMethod) return null;
+						const { sourceCode } = context;
+						const replacementText = objectMethod.node.callee.type === AST_NODE_TYPES.MemberExpression ? `${sourceCode.getText(objectMethod.node.callee.object)}.looseObject` : "looseObject";
+						const fixes = [fixer.replaceText(objectMethod.node.callee, replacementText)];
+						const calleeProperty = looseMethod.node.callee.type === AST_NODE_TYPES.MemberExpression ? looseMethod.node.callee.property : looseMethod.node.callee;
+						const tokenBefore = sourceCode.getTokenBefore(calleeProperty);
+						if (tokenBefore?.value === ".") fixes.push(fixer.removeRange([tokenBefore.range[0], looseMethod.node.range[1]]));
+						return fixes;
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { preferLooseObject };

package/dist/rules/prefer-strict-object.cjs

@@ -0,0 +1,49 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/prefer-strict-object.ts
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const preferStrictObject = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-strict-object",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `z.strictObject()` over `z.object().strict()`" },
+		messages: { preferStrictObject: "Use `z.strictObject()` instead of `.strict()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "object") return;
+				const methods = collectZodChainMethods(zodSchemaMeta.node);
+				const strictMethod = methods.find((it) => it.name === "strict");
+				if (!strictMethod) return;
+				context.report({
+					node: strictMethod.node,
+					messageId: "preferStrictObject",
+					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
+						if (strictMethod.node.arguments.length !== 0) return null;
+						const objectMethod = methods.find((it) => it.name === "object");
+						if (!objectMethod) return null;
+						const { sourceCode } = context;
+						const replacementText = objectMethod.node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? `${sourceCode.getText(objectMethod.node.callee.object)}.strictObject` : "strictObject";
+						const fixes = [fixer.replaceText(objectMethod.node.callee, replacementText)];
+						const calleeProperty = strictMethod.node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? strictMethod.node.callee.property : strictMethod.node.callee;
+						const tokenBefore = sourceCode.getTokenBefore(calleeProperty);
+						if (tokenBefore?.value === ".") fixes.push(fixer.removeRange([tokenBefore.range[0], strictMethod.node.range[1]]));
+						return fixes;
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.preferStrictObject = preferStrictObject;

package/dist/rules/prefer-strict-object.mjs

@@ -0,0 +1,48 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/prefer-strict-object.ts
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const preferStrictObject = createZodPluginRule({
+	name: "prefer-strict-object",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `z.strictObject()` over `z.object().strict()`" },
+		messages: { preferStrictObject: "Use `z.strictObject()` instead of `.strict()`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "object") return;
+				const methods = collectZodChainMethods(zodSchemaMeta.node);
+				const strictMethod = methods.find((it) => it.name === "strict");
+				if (!strictMethod) return;
+				context.report({
+					node: strictMethod.node,
+					messageId: "preferStrictObject",
+					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
+						if (strictMethod.node.arguments.length !== 0) return null;
+						const objectMethod = methods.find((it) => it.name === "object");
+						if (!objectMethod) return null;
+						const { sourceCode } = context;
+						const replacementText = objectMethod.node.callee.type === AST_NODE_TYPES.MemberExpression ? `${sourceCode.getText(objectMethod.node.callee.object)}.strictObject` : "strictObject";
+						const fixes = [fixer.replaceText(objectMethod.node.callee, replacementText)];
+						const calleeProperty = strictMethod.node.callee.type === AST_NODE_TYPES.MemberExpression ? strictMethod.node.callee.property : strictMethod.node.callee;
+						const tokenBefore = sourceCode.getTokenBefore(calleeProperty);
+						if (tokenBefore?.value === ".") fixes.push(fixer.removeRange([tokenBefore.range[0], strictMethod.node.range[1]]));
+						return fixes;
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { preferStrictObject };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "4.2.2",
+  "version": "4.4.0",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "keywords": [
     "eslint",
@@ -43,7 +43,7 @@
     "@eslint-zod/utils": "1.2.0"
   },
   "devDependencies": {
-    "@marcalexiei/prettier-config": "1.1.4",
+    "@marcalexiei/prettier-config": "2.0.0",
     "@types/esquery": "1.5.4",
     "@typescript-eslint/rule-tester": "8.59.2",
     "dedent": "1.7.2",