@schemashift/zod-v3-v4 0.8.0 → 0.10.0

package/dist/index.d.cts

@@ -8,12 +8,25 @@ declare function createZodV3ToV4Handler(): TransformHandler;
  *
  * Key changes in Zod v4:
  * 1. z.record() now requires explicit key type
- * 2. .default() has stricter type inference
+ * 2. .default() has stricter type inference (matches output type, not input)
  * 3. error.errors renamed to error.issues
- * 4. .uuid() has stricter validation (RFC 4122 compliant)
- * 5. z.function() input/output changed
+ * 4. .uuid() has stricter validation (RFC 9562/4122 compliant)
+ * 5. z.function() completely overhauled — .args()/.returns() removed
  * 6. Branded types use different syntax
  * 7. z.discriminatedUnion() requires literal discriminator
+ * 8. String format methods moved to top-level (e.g., .email() → z.email())
+ * 9. .deepPartial() removed (was deprecated anti-pattern)
+ * 10. z.promise() deprecated (await values before parsing)
+ * 11. .strip() deprecated (default behavior)
+ * 12. .nonempty() type inference changed (no longer tuple type)
+ * 13. z.coerce.* input type changed to unknown
+ * 14. z.partialRecord() added for optional key behavior
+ * 15. z.guid() added for lenient UUID matching
+ * 16. z.iso.* validators for date/time/datetime/duration
+ * 17. .prefault() added (restores v3 .default() parse behavior)
+ * 18. .addIssue()/.addIssues() deprecated in favor of issues.push()
+ * 19. ZodError precedence reversal: schema-level error maps override parse-time
+ * 20. z.ostring()/z.onumber() etc. removed (optional shorthands)
  */
 declare const V3_TO_V4_PATTERNS: {
     recordSingleArg: RegExp;
@@ -111,6 +124,50 @@ declare class ZodV3ToV4Transformer {
      * Detect imports of utility types that moved to 'zod/v4/core' in v4.
      */
     private checkUtilityTypeImports;
+    /**
+     * Warn about string format methods that moved to top-level functions in v4.
+     * e.g., z.string().email() → z.email() (instance methods are deprecated but still work)
+     */
+    private checkStringFormatMethods;
+    /**
+     * Check for deprecated factory functions (z.promise(), z.ostring(), etc.)
+     */
+    private checkDeprecatedFactories;
+    /**
+     * Transform z.function().args().returns() to z.function({ input, output }) in v4.
+     */
+    private transformFunctionValidation;
+    /**
+     * Transform z.ostring(), z.onumber(), z.oboolean() to explicit .optional() calls.
+     */
+    private transformOptionalShorthands;
+    /**
+     * Check for .nonempty() which has a type inference change in v4.
+     * v3: [string, ...string[]] (tuple with rest)
+     * v4: string[] (matches .min(1))
+     */
+    private checkNonemptyTypeChange;
+    /**
+     * Check for z.coerce.* usage — input type changed to unknown in v4.
+     */
+    private checkCoerceInputType;
+    /**
+     * Check for .deepPartial() which was removed entirely in v4.
+     */
+    private checkDeepPartialRemoval;
+    /**
+     * Check for .strip() which is deprecated in v4 (it was the default behavior).
+     */
+    private checkStripDeprecation;
+    /**
+     * Check for errorMap usage patterns where precedence changed in v4.
+     * In v4, schema-level error maps take precedence over parse-time error maps (inverted from v3).
+     */
+    private checkErrorMapPrecedence;
+    /**
+     * Check for ctx.addIssue() / ctx.addIssues() which are deprecated in v4.
+     */
+    private checkAddIssueMethods;
 }
 
 export { BEHAVIOR_CHANGES, V3_TO_V4_PATTERNS, ZodV3ToV4Transformer, createZodV3ToV4Handler };

package/dist/index.d.ts

@@ -8,12 +8,25 @@ declare function createZodV3ToV4Handler(): TransformHandler;
  *
  * Key changes in Zod v4:
  * 1. z.record() now requires explicit key type
- * 2. .default() has stricter type inference
+ * 2. .default() has stricter type inference (matches output type, not input)
  * 3. error.errors renamed to error.issues
- * 4. .uuid() has stricter validation (RFC 4122 compliant)
- * 5. z.function() input/output changed
+ * 4. .uuid() has stricter validation (RFC 9562/4122 compliant)
+ * 5. z.function() completely overhauled — .args()/.returns() removed
  * 6. Branded types use different syntax
  * 7. z.discriminatedUnion() requires literal discriminator
+ * 8. String format methods moved to top-level (e.g., .email() → z.email())
+ * 9. .deepPartial() removed (was deprecated anti-pattern)
+ * 10. z.promise() deprecated (await values before parsing)
+ * 11. .strip() deprecated (default behavior)
+ * 12. .nonempty() type inference changed (no longer tuple type)
+ * 13. z.coerce.* input type changed to unknown
+ * 14. z.partialRecord() added for optional key behavior
+ * 15. z.guid() added for lenient UUID matching
+ * 16. z.iso.* validators for date/time/datetime/duration
+ * 17. .prefault() added (restores v3 .default() parse behavior)
+ * 18. .addIssue()/.addIssues() deprecated in favor of issues.push()
+ * 19. ZodError precedence reversal: schema-level error maps override parse-time
+ * 20. z.ostring()/z.onumber() etc. removed (optional shorthands)
  */
 declare const V3_TO_V4_PATTERNS: {
     recordSingleArg: RegExp;
@@ -111,6 +124,50 @@ declare class ZodV3ToV4Transformer {
      * Detect imports of utility types that moved to 'zod/v4/core' in v4.
      */
     private checkUtilityTypeImports;
+    /**
+     * Warn about string format methods that moved to top-level functions in v4.
+     * e.g., z.string().email() → z.email() (instance methods are deprecated but still work)
+     */
+    private checkStringFormatMethods;
+    /**
+     * Check for deprecated factory functions (z.promise(), z.ostring(), etc.)
+     */
+    private checkDeprecatedFactories;
+    /**
+     * Transform z.function().args().returns() to z.function({ input, output }) in v4.
+     */
+    private transformFunctionValidation;
+    /**
+     * Transform z.ostring(), z.onumber(), z.oboolean() to explicit .optional() calls.
+     */
+    private transformOptionalShorthands;
+    /**
+     * Check for .nonempty() which has a type inference change in v4.
+     * v3: [string, ...string[]] (tuple with rest)
+     * v4: string[] (matches .min(1))
+     */
+    private checkNonemptyTypeChange;
+    /**
+     * Check for z.coerce.* usage — input type changed to unknown in v4.
+     */
+    private checkCoerceInputType;
+    /**
+     * Check for .deepPartial() which was removed entirely in v4.
+     */
+    private checkDeepPartialRemoval;
+    /**
+     * Check for .strip() which is deprecated in v4 (it was the default behavior).
+     */
+    private checkStripDeprecation;
+    /**
+     * Check for errorMap usage patterns where precedence changed in v4.
+     * In v4, schema-level error maps take precedence over parse-time error maps (inverted from v3).
+     */
+    private checkErrorMapPrecedence;
+    /**
+     * Check for ctx.addIssue() / ctx.addIssues() which are deprecated in v4.
+     */
+    private checkAddIssueMethods;
 }
 
 export { BEHAVIOR_CHANGES, V3_TO_V4_PATTERNS, ZodV3ToV4Transformer, createZodV3ToV4Handler };

package/dist/index.js

@@ -12,19 +12,23 @@ var V3_TO_V4_PATTERNS = {
 };
 var BEHAVIOR_CHANGES = /* @__PURE__ */ new Set([
   "default",
-  // Type inference changed
+  // Type inference changed; now matches output type, use .prefault() for v3 behavior
   "uuid",
-  // Stricter validation
+  // Stricter RFC 9562/4122 validation; use z.guid() for lenient matching
   "record",
   // Requires key type
   "discriminatedUnion",
   // Stricter discriminator requirements
   "function",
-  // Input/output parameter changes
+  // Complete overhaul — .args()/.returns() removed
   "pipe",
   // Stricter type checking in v4
-  "catch"
+  "catch",
   // .catch() on optional properties always returns catch value in v4
+  "nonempty",
+  // Type inference changed: string[] instead of [string, ...string[]]
+  "coerce"
+  // Input type changed to unknown for all z.coerce.* schemas
 ]);
 var DEPRECATED_METHODS = /* @__PURE__ */ new Set([
   "merge",
@@ -33,8 +37,26 @@ var DEPRECATED_METHODS = /* @__PURE__ */ new Set([
   // Use .check() instead
   "strict",
   // Use z.strictObject() instead
-  "passthrough"
+  "passthrough",
   // Use z.looseObject() instead
+  "deepPartial",
+  // Removed entirely — was deprecated anti-pattern
+  "strip",
+  // Deprecated — default behavior in v4
+  "nonstrict"
+  // Removed entirely
+]);
+var DEPRECATED_FACTORIES = /* @__PURE__ */ new Set([
+  "promise",
+  // z.promise() deprecated — await values before parsing
+  "ostring",
+  // z.ostring() removed (optional shorthand)
+  "onumber",
+  // z.onumber() removed
+  "oboolean",
+  // z.oboolean() removed
+  "preprocess"
+  // z.preprocess() removed — use z.pipe() instead
 ]);
 var AUTO_TRANSFORMABLE = /* @__PURE__ */ new Set([
   "superRefine",
@@ -51,6 +73,22 @@ var UTILITY_TYPES = /* @__PURE__ */ new Set([
   "ZodTypeAny",
   "ZodFirstPartyTypeKind"
 ]);
+var STRING_FORMAT_TO_TOPLEVEL = /* @__PURE__ */ new Map([
+  ["email", "z.email()"],
+  ["url", "z.url()"],
+  ["uuid", "z.uuid()"],
+  ["emoji", "z.emoji()"],
+  ["nanoid", "z.nanoid()"],
+  ["cuid", "z.cuid()"],
+  ["cuid2", "z.cuid2()"],
+  ["ulid", "z.ulid()"],
+  ["ipv4", "z.ipv4()"],
+  ["ipv6", "z.ipv6()"],
+  ["cidrv4", "z.cidrv4()"],
+  ["cidrv6", "z.cidrv6()"],
+  ["base64", "z.base64()"],
+  ["base64url", "z.base64url()"]
+]);
 
 // src/transformer.ts
 var ZodV3ToV4Transformer = class {
@@ -71,13 +109,23 @@ var ZodV3ToV4Transformer = class {
       this.transformFlatten(sourceFile);
       this.transformFormat(sourceFile);
       this.transformDefAccess(sourceFile);
+      this.transformFunctionValidation(sourceFile);
+      this.transformOptionalShorthands(sourceFile);
       this.checkDeprecatedMethods(sourceFile);
+      this.checkDeprecatedFactories(sourceFile);
+      this.checkStringFormatMethods(sourceFile);
       this.checkBehaviorChanges(sourceFile);
       this.checkInstanceofError(sourceFile);
       this.checkTransformRefineOrder(sourceFile);
       this.checkDefaultOptional(sourceFile);
       this.checkCatchOptional(sourceFile);
       this.checkUtilityTypeImports(sourceFile);
+      this.checkNonemptyTypeChange(sourceFile);
+      this.checkCoerceInputType(sourceFile);
+      this.checkDeepPartialRemoval(sourceFile);
+      this.checkStripDeprecation(sourceFile);
+      this.checkErrorMapPrecedence(sourceFile);
+      this.checkAddIssueMethods(sourceFile);
       return {
         success: this.errors.length === 0,
         filePath,
@@ -605,6 +653,238 @@ var ZodV3ToV4Transformer = class {
       }
     }
   }
+  /**
+   * Warn about string format methods that moved to top-level functions in v4.
+   * e.g., z.string().email() → z.email() (instance methods are deprecated but still work)
+   */
+  checkStringFormatMethods(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node.isPropertyAccessExpression(expression)) {
+          const name = expression.getName();
+          if (STRING_FORMAT_TO_TOPLEVEL.has(name)) {
+            const chainText = node.getText();
+            if (chainText.includes("z.string()") || chainText.includes(".string()")) {
+              const topLevel = STRING_FORMAT_TO_TOPLEVEL.get(name);
+              const lineNumber = node.getStartLineNumber();
+              this.warnings.push(
+                `${filePath}:${lineNumber}: .${name}() is deprecated as an instance method in v4. Use ${topLevel} as a top-level function instead. The instance method still works but may be removed in future versions.`
+              );
+            }
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Check for deprecated factory functions (z.promise(), z.ostring(), etc.)
+   */
+  checkDeprecatedFactories(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node.isPropertyAccessExpression(expression)) {
+          const name = expression.getName();
+          const object = expression.getExpression();
+          if (object.getText() === "z" && DEPRECATED_FACTORIES.has(name)) {
+            const lineNumber = node.getStartLineNumber();
+            switch (name) {
+              case "promise":
+                this.warnings.push(
+                  `${filePath}:${lineNumber}: z.promise() is deprecated in v4. Await values before parsing instead of wrapping in z.promise().`
+                );
+                break;
+              case "ostring":
+                this.warnings.push(
+                  `${filePath}:${lineNumber}: z.ostring() is removed in v4. Use z.string().optional() instead.`
+                );
+                break;
+              case "onumber":
+                this.warnings.push(
+                  `${filePath}:${lineNumber}: z.onumber() is removed in v4. Use z.number().optional() instead.`
+                );
+                break;
+              case "oboolean":
+                this.warnings.push(
+                  `${filePath}:${lineNumber}: z.oboolean() is removed in v4. Use z.boolean().optional() instead.`
+                );
+                break;
+              case "preprocess":
+                this.warnings.push(
+                  `${filePath}:${lineNumber}: z.preprocess() is removed in v4. Use z.pipe(z.unknown(), z.transform(fn), targetSchema) instead.`
+                );
+                break;
+            }
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Transform z.function().args().returns() to z.function({ input, output }) in v4.
+   */
+  transformFunctionValidation(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node.isPropertyAccessExpression(expression)) {
+          const name = expression.getName();
+          if (name === "args" || name === "returns") {
+            const chainText = node.getText();
+            if (chainText.includes("z.function()") && (chainText.includes(".args(") || chainText.includes(".returns("))) {
+              const lineNumber = node.getStartLineNumber();
+              this.warnings.push(
+                `${filePath}:${lineNumber}: z.function().args().returns() is removed in v4. Use z.function({ input: z.tuple([...]), output: schema }) instead. The result is no longer a Zod schema \u2014 use .implement() to wrap functions.`
+              );
+            }
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Transform z.ostring(), z.onumber(), z.oboolean() to explicit .optional() calls.
+   */
+  transformOptionalShorthands(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    const fullText = sourceFile.getFullText();
+    const replacements = [
+      { pattern: /\bz\.ostring\(\)/g, replacement: "z.string().optional()", name: "z.ostring()" },
+      { pattern: /\bz\.onumber\(\)/g, replacement: "z.number().optional()", name: "z.onumber()" },
+      {
+        pattern: /\bz\.oboolean\(\)/g,
+        replacement: "z.boolean().optional()",
+        name: "z.oboolean()"
+      }
+    ];
+    let newText = fullText;
+    for (const { pattern, replacement, name } of replacements) {
+      if (pattern.test(newText)) {
+        newText = newText.replace(pattern, replacement);
+        this.warnings.push(
+          `${filePath}: ${name} auto-transformed to ${replacement}. Removed in v4.`
+        );
+      }
+    }
+    if (newText !== fullText) {
+      sourceFile.replaceWithText(newText);
+    }
+  }
+  /**
+   * Check for .nonempty() which has a type inference change in v4.
+   * v3: [string, ...string[]] (tuple with rest)
+   * v4: string[] (matches .min(1))
+   */
+  checkNonemptyTypeChange(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node.isPropertyAccessExpression(expression) && expression.getName() === "nonempty") {
+          const lineNumber = node.getStartLineNumber();
+          this.warnings.push(
+            `${filePath}:${lineNumber}: .nonempty() type inference changed in v4. v3 inferred [T, ...T[]] (tuple with rest), v4 infers T[] (same as .min(1)). If you rely on the tuple type, use z.tuple([z.string()], z.string()) instead.`
+          );
+        }
+      }
+    });
+  }
+  /**
+   * Check for z.coerce.* usage — input type changed to unknown in v4.
+   */
+  checkCoerceInputType(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    const fullText = sourceFile.getFullText();
+    if (fullText.includes("z.coerce.")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node.isPropertyAccessExpression(node)) {
+          const text = node.getText();
+          if (text.startsWith("z.coerce.")) {
+            const lineNumber = node.getStartLineNumber();
+            this.warnings.push(
+              `${filePath}:${lineNumber}: z.coerce.* input type changed to 'unknown' in v4. Previously, z.coerce.string() had input type string. This enables more accurate type inference but may affect type guards.`
+            );
+          }
+        }
+      });
+    }
+  }
+  /**
+   * Check for .deepPartial() which was removed entirely in v4.
+   */
+  checkDeepPartialRemoval(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node.isPropertyAccessExpression(expression) && expression.getName() === "deepPartial") {
+          const lineNumber = node.getStartLineNumber();
+          this.warnings.push(
+            `${filePath}:${lineNumber}: .deepPartial() is removed in v4. This was a long-deprecated anti-pattern. Use recursive partial types or restructure schemas to avoid deep partial requirements.`
+          );
+        }
+      }
+    });
+  }
+  /**
+   * Check for .strip() which is deprecated in v4 (it was the default behavior).
+   */
+  checkStripDeprecation(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node.isPropertyAccessExpression(expression) && expression.getName() === "strip") {
+          const lineNumber = node.getStartLineNumber();
+          this.warnings.push(
+            `${filePath}:${lineNumber}: .strip() is deprecated in v4 (it was the default behavior). Remove .strip() \u2014 z.object() strips unknown keys by default. To convert a strict object back to stripping, use z.object(schema.shape).`
+          );
+        }
+      }
+    });
+  }
+  /**
+   * Check for errorMap usage patterns where precedence changed in v4.
+   * In v4, schema-level error maps take precedence over parse-time error maps (inverted from v3).
+   */
+  checkErrorMapPrecedence(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    const fullText = sourceFile.getFullText();
+    const hasSchemaErrorMap = fullText.includes("errorMap:") || fullText.includes("error:");
+    const hasParseErrorMap = fullText.includes(".parse(") && fullText.includes("errorMap") || fullText.includes(".safeParse(") && fullText.includes("errorMap");
+    if (hasSchemaErrorMap && hasParseErrorMap) {
+      this.warnings.push(
+        `${filePath}: Error map precedence changed in v4. Schema-level error maps now take precedence over parse-time error maps (inverted from v3). Review error map usage to ensure correct error messages.`
+      );
+    }
+  }
+  /**
+   * Check for ctx.addIssue() / ctx.addIssues() which are deprecated in v4.
+   */
+  checkAddIssueMethods(sourceFile) {
+    const filePath = sourceFile.getFilePath();
+    const fullText = sourceFile.getFullText();
+    if (fullText.includes(".addIssue(") || fullText.includes(".addIssues(")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+          const expression = node.getExpression();
+          if (Node.isPropertyAccessExpression(expression)) {
+            const name = expression.getName();
+            if (name === "addIssue" || name === "addIssues") {
+              const lineNumber = node.getStartLineNumber();
+              this.warnings.push(
+                `${filePath}:${lineNumber}: .${name}() is deprecated in v4. Directly manipulate the issues array instead: ctx.issues.push({...}). Note: .superRefine() callbacks using addIssue should migrate to .check() with issues.push().`
+              );
+            }
+          }
+        }
+      });
+    }
+  }
 };
 
 // src/handler.ts