Merge pull request #81 from huw/main

feat(zod-mock): Make union (incl. discriminated), enum (incl. native), and regex generation deterministic

Author: Brian-McBride

packages/zod-mock/src/lib/zod-mock.spec.ts

@@ -537,6 +537,37 @@ describe('zod-mock', () => {
     expect(first).toEqual(second);
   });
 
+  it('Options seed value will return the same union & enum members', () => {
+    enum NativeEnum {
+      a = 1,
+      b = 2,
+    }
+
+    const schema = z.object({
+      theme: z.enum([`light`, `dark`]),
+      nativeEnum: z.nativeEnum(NativeEnum),
+      union: z.union([z.literal('a'), z.literal('b')]),
+      discriminatedUnion: z.discriminatedUnion('discriminator', [
+        z.object({ discriminator: z.literal('a'), a: z.boolean() }),
+        z.object({ discriminator: z.literal('b'), b: z.string() }),
+      ]),
+    });
+    const seed = 123;
+    const first = generateMock(schema, { seed });
+    const second = generateMock(schema, { seed });
+    expect(first).toEqual(second);
+  });
+
+  it('Options seed value will return the same generated regex values', () => {
+    const schema = z.object({
+      data: z.string().regex(/^[A-Z0-9+_.-]+@[A-Z0-9.-]+$/),
+    });
+    const seed = 123;
+    const first = generateMock(schema, { seed });
+    const second = generateMock(schema, { seed });
+    expect(first).toEqual(second);
+  });
+
   // it.only('Can use my own version of faker', () => {
   //   const schema = z.object({
   //     name: z.string(),

packages/zod-mock/src/lib/zod-mock.ts

@@ -119,6 +119,8 @@ function parseString(
   const regexCheck = checks.find((check) => check.kind === 'regex');
   if (regexCheck && 'regex' in regexCheck) {
     const generator = new randExp(regexCheck.regex);
+    generator.randInt = (min: number, max: number) =>
+      fakerInstance.datatype.number({ min, max });
     const max = checks.find((check) => check.kind === 'max');
     if (max && 'value' in max && typeof max.value === 'number') {
       generator.max = max.value;
@@ -319,30 +321,34 @@ function parseMap(zodRef: z.ZodMap<never>, options?: GenerateMockOptions) {
   return results;
 }
 
-function parseEnum(zodRef: z.ZodEnum<never> | z.ZodNativeEnum<never>) {
+function parseEnum(
+  zodRef: z.ZodEnum<never> | z.ZodNativeEnum<never>,
+  options?: GenerateMockOptions
+) {
+  const fakerInstance = options?.faker || faker;
   const values = zodRef._def.values as Array<z.infer<typeof zodRef>>;
-  const pick = Math.floor(Math.random() * values.length);
-  return values[pick];
+  return fakerInstance.helpers.arrayElement(values);
 }
 
 function parseDiscriminatedUnion(
   zodRef: z.ZodDiscriminatedUnion<never, any>,
   options?: GenerateMockOptions
 ) {
+  const fakerInstance = options?.faker || faker;
   // Map the options to various possible union cases
   const potentialCases = [...zodRef._def.options.values()];
-  const pick = Math.floor(Math.random() * potentialCases.length);
-
-  const mocked = potentialCases[pick];
-
+  const mocked = fakerInstance.helpers.arrayElement(potentialCases);
   return generateMock(mocked, options);
 }
 
-function parseNativeEnum(zodRef: z.ZodNativeEnum<never>) {
+function parseNativeEnum(
+  zodRef: z.ZodNativeEnum<never>,
+  options?: GenerateMockOptions
+) {
+  const fakerInstance = options?.faker || faker;
   const { values } = zodRef._def;
-  const pick = Math.floor(Math.random() * Object.values(values).length);
-  const key = Array.from(Object.keys(values))[pick];
-  return values[values[key]];
+  const value = fakerInstance.helpers.arrayElement(values);
+  return values[value];
 }
 
 function parseLiteral(zodRef: z.ZodLiteral<any>) {
@@ -369,10 +375,9 @@ function parseUnion(
 ) {
   const fakerInstance = options?.faker || faker;
   // Map the options to various possible mock values
-  const mockOptions = zodRef._def.options.map((option) =>
-    generateMock(option, options)
-  );
-  return fakerInstance.helpers.arrayElement(mockOptions);
+  const potentialCases = [...zodRef._def.options.values()];
+  const mocked = fakerInstance.helpers.arrayElement(potentialCases);
+  return generateMock(mocked, options);
 }
 
 function parseZodIntersection(
@@ -509,7 +514,7 @@ export interface GenerateMockOptions {
   throwOnUnknownType?: boolean;
 
   /**
-   * Set a seed for random generation within the mock library
+   * Set a seed for random generation
    */
   seed?: number | number[];