Merge pull request #14 from DouglasNeuroInformatics/dev

update to Zod v4

Author: joshunrau

package.json

@@ -18,10 +18,6 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
-    },
-    "./vendor/*": {
-      "types": "./dist/vendor/*.d.ts",
-      "import": "./dist/vendor/*.js"
     }
   },
   "files": [
@@ -39,7 +35,7 @@
   },
   "peerDependencies": {
     "neverthrow": "^8.2.0",
-    "zod": "^3.22.6"
+    "zod": "^3.25.x"
   },
   "dependencies": {
     "clean-stack": "^5.2.0",

pnpm-lock.yaml

@@ -1,3 +1,4 @@
+import { Err } from 'neverthrow';
 import type { Simplify } from 'type-fest';
 import { describe, expect, expectTypeOf, it, test } from 'vitest';
 
@@ -10,7 +11,6 @@ import {
   RuntimeException,
   ValueException
 } from '../exception.js';
-import { Err } from '../vendor/neverthrow.js';
 
 import type { ExceptionConstructor } from '../exception.js';
 

src/__tests__/exception.test.ts

@@ -1,10 +1,9 @@
+import type { Err } from 'neverthrow';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import * as datetime from '../datetime.js';
 import { safeFetch, waitForServer } from '../http.js';
 
-import type { Err } from '../vendor/neverthrow.js';
-
 const fetch = vi.hoisted(() => vi.fn());
 const networkError = new Error('Network Error');
 

src/__tests__/http.test.ts

@@ -1,7 +1,7 @@
+import { Err, err, Ok, ok } from 'neverthrow';
 import { describe, expect, it } from 'vitest';
 
-import { asyncResultify } from '../result.js';
-import { Err, err, Ok, ok } from '../vendor/neverthrow.js';
+import { asyncResultify, unwrap } from '../result.js';
 
 describe('asyncResultify', () => {
   it('should convert a successful Result to ResultAsync', async () => {
@@ -29,3 +29,13 @@ describe('asyncResultify', () => {
     expect(result.value).toBe('delayed result');
   });
 });
+
+describe('unwrap', () => {
+  it('should throw if the result is an Error', () => {
+    const error = new Error('Something went wrong!');
+    expect(() => unwrap(err(error))).toThrow(error);
+  });
+  it('should return if the result is Ok', () => {
+    expect(unwrap(ok(5))).toBe(5);
+  });
+});

src/__tests__/result.test.ts

@@ -1,35 +1,134 @@
-import * as module from 'node:module';
+/* eslint-disable @typescript-eslint/no-require-imports */
+import { describe, expect, expectTypeOf, it, test } from 'vitest';
+import { z as z3 } from 'zod/v3';
+import { z as z4 } from 'zod/v4';
 
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
+import { $BooleanLike, $NumberLike, $Uint8ArrayLike, $UrlLike, isZodType, isZodTypeLike, safeParse } from '../zod.js';
 
-import { $BooleanLike, $NumberLike, $Uint8ArrayLike, $UrlLike, isZodType, safeParse } from '../zod.js';
+import type {
+  ZodErrorLike,
+  ZodIssueLike,
+  ZodSafeParseErrorLike,
+  ZodSafeParseResultLike,
+  ZodSafeParseSuccessLike,
+  ZodTypeLike
+} from '../zod.js';
 
-const require = module.createRequire(import.meta.url);
+test('ZodIssueLike', () => {
+  expectTypeOf<z3.ZodIssue>().toMatchTypeOf<ZodIssueLike>();
+  expectTypeOf<z4.core.$ZodIssue>().toMatchTypeOf<ZodIssueLike>();
+});
 
-/** since we use require here, the prototype chain in the cjs module will be different than the esm build  */
-const { z: zCJS } = require('zod') as typeof import('zod');
+test('ZodErrorLike', () => {
+  expectTypeOf<z3.ZodError>().toMatchTypeOf<ZodErrorLike>();
+  expectTypeOf<z4.core.$ZodError>().toMatchTypeOf<ZodErrorLike>();
+});
 
-describe('isZodType', () => {
-  it('should return true for an instance of ZodNumber', () => {
-    expect(isZodType(z.number())).toBe(true);
+test('ZodSafeParseSuccessLike', () => {
+  expectTypeOf<z3.SafeParseSuccess<number>>().toMatchTypeOf<ZodSafeParseSuccessLike<number>>();
+  expectTypeOf<z4.ZodSafeParseSuccess<number>>().toMatchTypeOf<ZodSafeParseSuccessLike<number>>();
+});
+
+test('ZodSafeParseErrorLike', () => {
+  expectTypeOf<z3.SafeParseError<number>>().toMatchTypeOf<ZodSafeParseErrorLike>();
+  expectTypeOf<z4.ZodSafeParseError<number>>().toMatchTypeOf<ZodSafeParseErrorLike>();
+});
+
+test('ZodSafeParseResultLike', () => {
+  expectTypeOf<z3.SafeParseReturnType<number, number>>().toMatchTypeOf<ZodSafeParseResultLike<number>>();
+  expectTypeOf<z4.ZodSafeParseResult<number>>().toMatchTypeOf<ZodSafeParseResultLike<number>>();
+});
+
+test('ZodTypeLike', () => {
+  expectTypeOf<z3.ZodTypeAny>().toMatchTypeOf<ZodTypeLike<any>>();
+  expectTypeOf<z3.ZodTypeAny>().toMatchTypeOf<ZodTypeLike<unknown>>();
+  expectTypeOf<z3.ZodNumber>().toMatchTypeOf<ZodTypeLike<unknown>>();
+  expectTypeOf<z3.ZodNumber>().toMatchTypeOf<ZodTypeLike<number>>();
+  expectTypeOf<z3.ZodNumber>().not.toMatchTypeOf<ZodTypeLike<string>>();
+  expectTypeOf<z4.ZodType>().toMatchTypeOf<ZodTypeLike<any>>();
+  expectTypeOf<z4.ZodType>().toMatchTypeOf<ZodTypeLike<unknown>>();
+  expectTypeOf<z4.ZodNumber>().toMatchTypeOf<ZodTypeLike<unknown>>();
+  expectTypeOf<z4.ZodNumber>().toMatchTypeOf<ZodTypeLike<number>>();
+  expectTypeOf<z4.ZodNumber>().not.toMatchTypeOf<ZodTypeLike<string>>();
+});
+
+describe('isZodTypeLike', () => {
+  it('should return true for Zod v3 types', () => {
+    expect(isZodTypeLike(z3.object({}))).toBe(true);
+    expect(isZodTypeLike(z3.number())).toBe(true);
+    expect(isZodTypeLike(z3.any())).toBe(true);
   });
-  it('should return true for an instance of ZodObject', () => {
-    expect(isZodType(z.object({}))).toBe(true);
+  it('should return true for Zod v4 types', () => {
+    expect(isZodTypeLike(z4.object({}))).toBe(true);
+    expect(isZodTypeLike(z4.number())).toBe(true);
+    expect(isZodTypeLike(z4.any())).toBe(true);
   });
-  it('should return false for null', () => {
-    expect(isZodType(null)).toBe(false);
+  it('should return false for an object without a standard schema', () => {
+    expect(isZodTypeLike({})).toBe(false);
   });
-  it('should return false for any empty object', () => {
-    expect(isZodType({})).toBe(false);
+  it('should return false for an object with a standard schema, but the incorrect vendor name', () => {
+    expect(isZodTypeLike({ '~standard': { vendor: 'DNP' } })).toBe(false);
   });
-  it('should return false for an object with a null prototype', () => {
-    expect(isZodType(Object.create(null))).toBe(false);
+});
+
+describe('isZodType', () => {
+  describe('v3', () => {
+    // since we use require here, the prototype chain in the cjs module will be different than the esm build
+    const { z: z3_2 } = require('zod/v3') as typeof import('zod/v3');
+
+    it('should return true for an instance of ZodNumber', () => {
+      expect(isZodType(z3.number(), { version: 3 })).toBe(true);
+    });
+    it('should return true for an instance of ZodObject', () => {
+      expect(isZodType(z3.object({}), { version: 3 })).toBe(true);
+    });
+    it('should return false for null', () => {
+      expect(isZodType(null, { version: 3 })).toBe(false);
+    });
+    it('should return false for any empty object', () => {
+      expect(isZodType({}, { version: 3 })).toBe(false);
+    });
+    it('should return false for an object with a null prototype', () => {
+      expect(isZodType(Object.create(null), { version: 3 })).toBe(false);
+    });
+    it('should return false for a Zod v4 object', () => {
+      expect(isZodType(z4.object({}), { version: 3 })).toBe(false);
+    });
+    it('should return true for a ZodObject created in a different context', () => {
+      const input = z3_2.object({});
+      expect(input).not.toBeInstanceOf(z3.ZodType);
+      expect(isZodType(input, { version: 3 })).toBe(true);
+    });
   });
-  it('should return true for a ZodObject created in a different context', () => {
-    const input = zCJS.object({});
-    expect(input).not.toBeInstanceOf(z.ZodType);
-    expect(isZodType(input)).toBe(true);
+  describe('v4', () => {
+    it('should return true for an instance of ZodNumber', () => {
+      expect(isZodType(z4.number(), { version: 4 })).toBe(true);
+    });
+    it('should return true for an instance of ZodObject', () => {
+      expect(isZodType(z4.object({}), { version: 4 })).toBe(true);
+    });
+    it('should return false for null', () => {
+      expect(isZodType(null, { version: 4 })).toBe(false);
+    });
+    it('should return false for any empty object', () => {
+      expect(isZodType({}, { version: 4 })).toBe(false);
+    });
+    it('should return false for a Zod v3 object', () => {
+      expect(isZodType(z3.object({}), { version: 4 })).toBe(false);
+    });
+    it('should return true for a ZodObject created in a different context', () => {
+      const base = z4.object({});
+      const input = {
+        _zod: {
+          version: structuredClone(base._zod.version)
+        },
+        '~standard': {
+          vendor: base['~standard'].vendor
+        }
+      };
+      expect(input).not.toBeInstanceOf(z4.ZodType);
+      expect(isZodType(input, { version: 4 })).toBe(true);
+    });
   });
 });
 
@@ -66,7 +165,7 @@ describe('$NumberLike', () => {
     expect($NumberLike.safeParse('').success).toBe(false);
   });
   it('should allow restricting the number through a pipe', () => {
-    const $IntLike = $NumberLike.pipe(z.number().int());
+    const $IntLike = $NumberLike.pipe(z4.number().int());
     expect($IntLike.safeParse('1.1').success).toBe(false);
     expect($IntLike.safeParse('1').data).toBe(1);
   });
@@ -118,7 +217,7 @@ describe('$Uint8ArrayLike', () => {
 });
 
 describe('safeParse', () => {
-  const $Schema = z.object({ foo: z.enum(['1', '2']).transform(Number) });
+  const $Schema = z4.object({ foo: z4.enum(['1', '2']).transform(Number) });
   it('should return an Ok result with the parsed data if successful', () => {
     const result = safeParse({ foo: '1' }, $Schema);
     expect(result.isOk() && result.value).toStrictEqual({ foo: 1 });
@@ -132,7 +231,7 @@ describe('safeParse', () => {
         },
         issues: [
           expect.objectContaining({
-            code: z.ZodIssueCode.invalid_enum_value,
+            code: 'invalid_value',
             path: ['foo']
           })
         ]

src/__tests__/zod.test.ts

@@ -1,7 +1,7 @@
-import { OutOfRangeException } from './exception.js';
-import { err, ok } from './vendor/neverthrow.js';
+import { err, ok } from 'neverthrow';
+import type { Result } from 'neverthrow';
 
-import type { Result } from './vendor/neverthrow.js';
+import { OutOfRangeException } from './exception.js';
 
 export type Duration = {
   days: number;

src/datetime.ts

@@ -4,14 +4,14 @@
 
 import cleanStack from 'clean-stack';
 import extractStack from 'extract-stack';
+import { err, errAsync, Result, ResultAsync } from 'neverthrow';
 import { isErrorLike, serializeError } from 'serialize-error';
 import stringifyObject from 'stringify-object';
 import type { IsNever, RequiredKeysOf } from 'type-fest';
-import type { z } from 'zod';
+import type { z } from 'zod/v4';
 
 import { objectify } from './object.js';
 import { indentLines } from './string.js';
-import { err, errAsync, Result, ResultAsync } from './vendor/neverthrow.js';
 
 import type { SingleKeyMap, ToAbstractConstructor } from './types.js';
 
@@ -233,7 +233,7 @@ const { OutOfRangeException } = new ExceptionBuilder()
   .build();
 
 export const { ValidationException } = new ExceptionBuilder()
-  .setOptionsType<{ details: { data: unknown; issues: z.ZodIssue[] } }>()
+  .setOptionsType<{ details: { data: unknown; issues: z.core.$ZodIssue[] } }>()
   .setParams({ message: 'Zod schema validation failed', name: 'ValidationException' })
   .build();
 

src/exception.ts

@@ -1,7 +1,8 @@
+import { ok, ResultAsync } from 'neverthrow';
+
 import { sleep } from './datetime.js';
 import { ExceptionBuilder, RuntimeException } from './exception.js';
 import { asyncResultify } from './result.js';
-import { ok, ResultAsync } from './vendor/neverthrow.js';
 
 import type { ExceptionLike } from './exception.js';
 

src/http.ts

@@ -1,7 +1,7 @@
-import { ValueException } from './exception.js';
-import { ok } from './vendor/neverthrow.js';
+import { ok } from 'neverthrow';
+import type { Result } from 'neverthrow';
 
-import type { Result } from './vendor/neverthrow.js';
+import { ValueException } from './exception.js';
 
 /** Returns a random integer between `min` (inclusive) and `max` (not inclusive) */
 export function randomInt(min: number, max: number): Result<number, typeof ValueException.Instance> {