feature: zodContract zod v4 and zod v4-mini support

packages/zod/package.json

@@ -7,12 +7,12 @@
   "license": "MIT",
   "repository": "https://github.com/igorkamyshev/farfetched",
   "devDependencies": {
-    "zod": "^3.19",
-    "@farfetched/core": "workspace:*"
+    "@farfetched/core": "workspace:*",
+    "zod": "^3.25.67"
   },
   "peerDependencies": {
-    "zod": "^3.19",
-    "@farfetched/core": "workspace:*"
+    "@farfetched/core": "workspace:*",
+    "zod": "^3.25.0 || ^4.0.0"
   },
   "scripts": {
     "test:run": "vitest run --typecheck",

packages/zod/src/__tests__/contract.test-d.ts

@@ -1,11 +1,13 @@
 import { describe, test, expectTypeOf } from 'vitest';
-import { z as zod } from 'zod';
+import { z as zodV3 } from 'zod/v3';
+import { z as zodV4 } from 'zod/v4';
+import { z as zodV4mini } from 'zod/v4-mini';
 
 import { zodContract } from '../zod_contract';
 
-describe('zodContract', () => {
+describe('zodContract (zod v3)', () => {
   test('string', () => {
-    const stringContract = zodContract(zod.string());
+    const stringContract = zodContract(zodV3.string());
 
     const smth: unknown = null;
 
@@ -17,14 +19,14 @@ describe('zodContract', () => {
 
   test('complex object', () => {
     const complexContract = zodContract(
-      zod.tuple([
-        zod.object({
-          x: zod.number(),
-          y: zod.literal(false),
-          k: zod.set(zod.string()),
+      zodV3.tuple([
+        zodV3.object({
+          x: zodV3.number(),
+          y: zodV3.literal(false),
+          k: zodV3.set(zodV3.string()),
         }),
-        zod.literal('literal'),
-        zod.literal(42),
+        zodV3.literal('literal'),
+        zodV3.literal(42),
       ])
     );
 
@@ -60,15 +62,157 @@ describe('zodContract', () => {
   });
 
   test('branded type', () => {
-    const BrandedContainer = zod.object({
-      branded: zod.string().brand<'Branded'>(),
+    const BrandedContainer = zodV3.object({
+      branded: zodV3.string().brand<'Branded'>(),
     });
     const brandedContract = zodContract(BrandedContainer);
 
     const smth: unknown = { branded: 'branded' };
 
     if (brandedContract.isData(smth)) {
-      expectTypeOf(smth).toEqualTypeOf<zod.infer<typeof BrandedContainer>>();
+      expectTypeOf(smth).toEqualTypeOf<zodV3.infer<typeof BrandedContainer>>();
+    }
+  });
+});
+
+describe('zodContract (zod v4)', () => {
+  test('string', () => {
+    const stringContract = zodContract(zodV4.string());
+
+    const smth: unknown = null;
+
+    if (stringContract.isData(smth)) {
+      expectTypeOf(smth).toEqualTypeOf<string>();
+      expectTypeOf(smth).not.toEqualTypeOf<number>();
+    }
+  });
+
+  test('complex object', () => {
+    const complexContract = zodContract(
+      zodV4.tuple([
+        zodV4.object({
+          x: zodV4.number(),
+          y: zodV4.literal(false),
+          k: zodV4.set(zodV4.string()),
+        }),
+        zodV4.literal('literal'),
+        zodV4.literal(42),
+      ])
+    );
+
+    const smth: unknown = null;
+
+    if (complexContract.isData(smth)) {
+      expectTypeOf(smth).toEqualTypeOf<
+        [
+          {
+            x: number;
+            y: false;
+            k: Set<string>;
+          },
+          'literal',
+          42,
+        ]
+      >();
+
+      expectTypeOf(smth).not.toEqualTypeOf<number>();
+
+      expectTypeOf(smth).not.toEqualTypeOf<
+        [
+          {
+            x: string;
+            y: false;
+            k: Set<string>;
+          },
+          'literal',
+          42,
+        ]
+      >();
+    }
+  });
+
+  test('branded type', () => {
+    const BrandedContainer = zodV4.object({
+      branded: zodV4.string().brand<'Branded'>(),
+    });
+    const brandedContract = zodContract(BrandedContainer);
+
+    const smth: unknown = { branded: 'branded' };
+
+    if (brandedContract.isData(smth)) {
+      expectTypeOf(smth).toEqualTypeOf<zodV4.infer<typeof BrandedContainer>>();
+    }
+  });
+});
+
+describe('zodContract (zod v4-mini)', () => {
+  test('string', () => {
+    const stringContract = zodContract(zodV4mini.string());
+
+    const smth: unknown = null;
+
+    if (stringContract.isData(smth)) {
+      expectTypeOf(smth).toEqualTypeOf<string>();
+      expectTypeOf(smth).not.toEqualTypeOf<number>();
+    }
+  });
+
+  test('complex object', () => {
+    const complexContract = zodContract(
+      zodV4mini.tuple([
+        zodV4mini.object({
+          x: zodV4mini.number(),
+          y: zodV4mini.literal(false),
+          k: zodV4mini.set(zodV4mini.string()),
+        }),
+        zodV4mini.literal('literal'),
+        zodV4mini.literal(42),
+      ])
+    );
+
+    const smth: unknown = null;
+
+    if (complexContract.isData(smth)) {
+      expectTypeOf(smth).toEqualTypeOf<
+        [
+          {
+            x: number;
+            y: false;
+            k: Set<string>;
+          },
+          'literal',
+          42,
+        ]
+      >();
+
+      expectTypeOf(smth).not.toEqualTypeOf<number>();
+
+      expectTypeOf(smth).not.toEqualTypeOf<
+        [
+          {
+            x: string;
+            y: false;
+            k: Set<string>;
+          },
+          'literal',
+          42,
+        ]
+      >();
+    }
+  });
+
+  test('branded type', () => {
+    const BrandedContainer = zodV4mini.object({
+      branded: zodV4mini.string().brand<'Branded'>(),
+    });
+    const brandedContract = zodContract(BrandedContainer);
+
+    const smth: unknown = { branded: 'branded' };
+
+    if (brandedContract.isData(smth)) {
+      expectTypeOf(smth).toEqualTypeOf<
+        zodV4mini.infer<typeof BrandedContainer>
+      >();
     }
   });
 });