@schemashift/zod-v3-v4 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -23,10 +23,174 @@ __export(index_exports, {
   BEHAVIOR_CHANGES: () => BEHAVIOR_CHANGES,
   V3_TO_V4_PATTERNS: () => V3_TO_V4_PATTERNS,
   ZodV3ToV4Transformer: () => ZodV3ToV4Transformer,
-  createZodV3ToV4Handler: () => createZodV3ToV4Handler
+  createZodV3ToV4Handler: () => createZodV3ToV4Handler,
+  detectBehavioralPatterns: () => detectBehavioralPatterns,
+  generateBehaviorTests: () => generateBehaviorTests
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/behavior-test-generator.ts
+var V4_BEHAVIORAL_PATTERNS = [
+  {
+    name: "default-optional",
+    description: ".default() + .optional() behaves differently in v4",
+    regex: /\.default\([^)]*\)[\s\S]{0,20}\.optional\(\)|\.optional\(\)[\s\S]{0,20}\.default\([^)]*\)/,
+    testTemplate: [
+      "  it('verifies .default() + .optional() behavior (v4 change)', () => {",
+      "    // v3: undefined input returns undefined (.optional() wins)",
+      "    // v4: undefined input returns default value (.default() always applies)",
+      "    const schema = z.string().default('fallback').optional();",
+      "    const result = schema.parse(undefined);",
+      "    expect(result).toBe('fallback');",
+      "  });"
+    ].join("\n")
+  },
+  {
+    name: "error-instanceof",
+    description: "ZodError no longer extends Error in v4",
+    regex: /instanceof\s+Error|instanceof\s+ZodError/,
+    testTemplate: [
+      "  it('verifies ZodError instanceof check (v4 change)', () => {",
+      "    // v3: ZodError extends Error",
+      "    // v4: ZodError does NOT extend Error",
+      "    try {",
+      "      z.string().parse(123);",
+      "    } catch (e) {",
+      "      expect(e).toBeDefined();",
+      "    }",
+      "  });"
+    ].join("\n")
+  },
+  {
+    name: "transform-after-refine",
+    description: ".transform() after .refine() may change execution order in v4",
+    regex: /\.refine\([^)]*\)[\s\S]{0,30}\.transform\(/,
+    testTemplate: [
+      "  it('verifies .refine() then .transform() ordering (v4 change)', () => {",
+      "    const schema = z.string()",
+      "      .refine((val) => val.length > 0, 'Must not be empty')",
+      "      .transform((val) => val.toUpperCase());",
+      "    const result = schema.safeParse('hello');",
+      "    expect(result.success).toBe(true);",
+      "    if (result.success) {",
+      "      expect(result.data).toBe('HELLO');",
+      "    }",
+      "  });"
+    ].join("\n")
+  },
+  {
+    name: "catch-optional",
+    description: ".catch() + .optional() interaction changed in v4",
+    regex: /\.catch\([^)]*\)[\s\S]{0,20}\.optional\(\)|\.optional\(\)[\s\S]{0,20}\.catch\([^)]*\)/,
+    testTemplate: [
+      "  it('verifies .catch() + .optional() behavior (v4 change)', () => {",
+      "    const schema = z.string().catch('default').optional();",
+      "    const result = schema.parse(undefined);",
+      "    expect(result).toBeDefined();",
+      "  });"
+    ].join("\n")
+  },
+  {
+    name: "error-message-format",
+    description: 'Error messages changed from "Required" to descriptive messages',
+    regex: /['"]Required['"]/,
+    testTemplate: [
+      "  it('verifies error message format (v4 change)', () => {",
+      '    // v3: "Required" for missing fields',
+      '    // v4: "Invalid input: expected string, received undefined"',
+      "    const schema = z.object({ name: z.string() });",
+      "    const result = schema.safeParse({});",
+      "    expect(result.success).toBe(false);",
+      "    if (!result.success) {",
+      "      const msg = result.error.issues[0]?.message ?? '';",
+      "      expect(msg.length).toBeGreaterThan(0);",
+      "    }",
+      "  });"
+    ].join("\n")
+  },
+  {
+    name: "error-flatten",
+    description: "error.flatten() moved to z.flattenError(error) in v4",
+    regex: /\.flatten\(\)/,
+    testTemplate: [
+      "  it('verifies error flattening (v4 change)', () => {",
+      "    // v3: error.flatten()",
+      "    // v4: z.flattenError(error)",
+      "    const schema = z.object({ name: z.string() });",
+      "    const result = schema.safeParse({});",
+      "    if (!result.success) {",
+      "      expect(result.error).toBeDefined();",
+      "    }",
+      "  });"
+    ].join("\n")
+  }
+];
+function detectBehavioralPatterns(sourceCode, filePath) {
+  const results = [];
+  const lines = sourceCode.split("\n");
+  for (const pattern of V4_BEHAVIORAL_PATTERNS) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] ?? "";
+      if (pattern.regex.test(line)) {
+        results.push({
+          pattern,
+          filePath,
+          lineNumber: i + 1,
+          matchedText: line.trim()
+        });
+      }
+    }
+    if (pattern.regex.test(sourceCode) && !results.some((r) => r.pattern.name === pattern.name && r.filePath === filePath)) {
+      const match = pattern.regex.exec(sourceCode);
+      if (match) {
+        const lineNumber = sourceCode.slice(0, match.index).split("\n").length;
+        results.push({
+          pattern,
+          filePath,
+          lineNumber,
+          matchedText: match[0].trim().slice(0, 80)
+        });
+      }
+    }
+  }
+  return results;
+}
+function generateBehaviorTests(files) {
+  const allPatterns = [];
+  const testsByFile = /* @__PURE__ */ new Map();
+  for (const { filePath, sourceCode } of files) {
+    const detected = detectBehavioralPatterns(sourceCode, filePath);
+    allPatterns.push(...detected);
+    for (const d of detected) {
+      const existing = testsByFile.get(filePath) ?? /* @__PURE__ */ new Set();
+      existing.add(d.pattern.name);
+      testsByFile.set(filePath, existing);
+    }
+  }
+  const tests = [];
+  for (const [filePath, patternNames] of testsByFile) {
+    const patterns = [...patternNames];
+    const testBlocks = patterns.map((name) => V4_BEHAVIORAL_PATTERNS.find((p) => p.name === name)?.testTemplate ?? "").filter(Boolean);
+    if (testBlocks.length === 0) continue;
+    const shortPath = filePath.split("/").slice(-2).join("/");
+    const testCode = [
+      "import { describe, expect, it } from 'vitest';",
+      "import { z } from 'zod';",
+      "",
+      "/**",
+      " * Behavioral regression tests for Zod v3 to v4 migration",
+      ` * Source: ${shortPath}`,
+      " * Generated by SchemaShift",
+      " */",
+      `describe('v4 behavioral changes: ${shortPath}', () => {`,
+      ...testBlocks.map((b) => b),
+      "});"
+    ].join("\n");
+    tests.push({ filePath, testCode, patterns });
+  }
+  return { tests, totalPatterns: allPatterns.length };
+}
+
 // src/transformer.ts
 var import_ts_morph = require("ts-morph");
 
@@ -41,19 +205,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",
@@ -62,8 +230,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",
@@ -80,6 +266,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 {
@@ -100,13 +302,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,
@@ -634,6 +846,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 (import_ts_morph.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (import_ts_morph.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 (import_ts_morph.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (import_ts_morph.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 (import_ts_morph.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (import_ts_morph.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 (import_ts_morph.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (import_ts_morph.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 (import_ts_morph.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 (import_ts_morph.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (import_ts_morph.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 (import_ts_morph.Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (import_ts_morph.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 (import_ts_morph.Node.isCallExpression(node)) {
+          const expression = node.getExpression();
+          if (import_ts_morph.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
@@ -650,6 +1094,8 @@ function createZodV3ToV4Handler() {
   BEHAVIOR_CHANGES,
   V3_TO_V4_PATTERNS,
   ZodV3ToV4Transformer,
-  createZodV3ToV4Handler
+  createZodV3ToV4Handler,
+  detectBehavioralPatterns,
+  generateBehaviorTests
 });
 //# sourceMappingURL=index.cjs.map