refactor: generateExample with strict parameter

Author: omermecitoglu

src/utils/generateExample.test.ts

@@ -10,7 +10,7 @@ describe("generateExample", () => {
       email: z.string().email(),
       age: z.number().optional(),
     });
-    expect(generateExample(schema, false)).toStrictEqual({
+    expect(generateExample(schema, false, false)).toStrictEqual({
       id: 1,
       name: "example name",
       email: "[email protected]",
@@ -25,7 +25,7 @@ describe("generateExample", () => {
       email: z.string().email(),
       age: z.number().optional(),
     });
-    expect(generateExample(schema, true)).toStrictEqual({
+    expect(generateExample(schema, true, false)).toStrictEqual({
       id: 1,
       name: "example name",
       email: "[email protected]",
@@ -34,88 +34,94 @@ describe("generateExample", () => {
 
   it("should generate an example from a zod string", () => {
     const schema = z.string();
-    expect(generateExample(schema, false)).toBe("example string");
+    expect(generateExample(schema, false, false)).toBe("example string");
   });
 
   it("should generate an example from a zod number", () => {
     const schema = z.number();
-    expect(generateExample(schema, false)).toBe(1);
-    expect(generateExample(z.number().negative(), false)).toBe(-1);
-    expect(generateExample(z.number().nonpositive(), false)).toBe(-1);
-    expect(generateExample(z.number().multipleOf(7), false)).toBe(7);
+    expect(generateExample(schema, false, false)).toBe(1);
+    expect(generateExample(z.number().negative(), false, false)).toBe(-1);
+    expect(generateExample(z.number().nonpositive(), false, false)).toBe(-1);
+    expect(generateExample(z.number().multipleOf(7), false, false)).toBe(7);
   });
 
   it("should return the minimum value from a zod number with minimum", () => {
     const schema = z.number().min(5);
-    expect(generateExample(schema, false)).toBe(5);
+    expect(generateExample(schema, false, false)).toBe(5);
   });
 
   it("should generate an example from a zod integer", () => {
     const schema = z.bigint();
-    expect(generateExample(schema, false)).toBe(1n);
+    expect(generateExample(schema, false, false)).toBe(1n);
   });
 
   it("should generate an example from a zod boolean", () => {
     const schema = z.boolean();
-    expect(generateExample(schema, false)).toBe(false);
+    expect(generateExample(schema, false, false)).toBe(false);
   });
 
   it("should generate an example from a zod undefined", () => {
     const schema = z.undefined();
-    expect(generateExample(schema, false)).toBe(undefined);
+    expect(generateExample(schema, false, false)).toBe(undefined);
   });
 
   it("should generate an example from a zod null", () => {
     const schema = z.null();
-    expect(generateExample(schema, false)).toBe(null);
+    expect(generateExample(schema, false, false)).toBe(null);
   });
 
   it("should return the first item from a zod enum", () => {
     const schema = z.enum(["apple", "pear", "orange"]);
-    expect(generateExample(schema, false)).toBe("apple");
+    expect(generateExample(schema, false, false)).toBe("apple");
   });
 
   it("should return the default value if the schema has one", () => {
     const schema = z.string().default("I think this function will be very useful");
-    expect(generateExample(schema, false)).toBe("I think this function will be very useful");
+    expect(generateExample(schema, false, false)).toBe("I think this function will be very useful");
   });
 
   it("should handle zod string with special types", () => {
-    expect(generateExample(z.string().email(), false)).toBe("[email protected]");
-    expect(generateExample(z.string().url(), false)).toBe("https://example.com");
-    expect(generateExample(z.string().emoji(), false)).toBe("😀");
-    expect(generateExample(z.string().uuid(), false)).toBe("aa35d4a1-8f23-4cee-847c-2bfe89dc87c1");
-    expect(generateExample(z.string().ip(), false)).toBe("192.168.1.1");
-    expect(generateExample(z.string().datetime(), false)).toBe("2024-11-06T07:00:00.137Z");
-    expect(generateExample(z.string().startsWith("openapi:"), false)).toBe("openapi:example");
-    expect(generateExample(z.string().endsWith(":openapi"), false)).toBe("example:openapi");
+    expect(generateExample(z.string().email(), false, false)).toBe("[email protected]");
+    expect(generateExample(z.string().url(), false, false)).toBe("https://example.com");
+    expect(generateExample(z.string().emoji(), false, false)).toBe("😀");
+    expect(generateExample(z.string().uuid(), false, false)).toBe("aa35d4a1-8f23-4cee-847c-2bfe89dc87c1");
+    expect(generateExample(z.string().ip(), false, false)).toBe("192.168.1.1");
+    expect(generateExample(z.string().datetime(), false, false)).toBe("2024-11-06T07:00:00.137Z");
+    expect(generateExample(z.string().startsWith("openapi:"), false, false)).toBe("openapi:example");
+    expect(generateExample(z.string().endsWith(":openapi"), false, false)).toBe("example:openapi");
   });
 
-  it("should generate an example from a nullable zod string", () => {
+  it("should generate an example from a nullable zod schema", () => {
     const schema = z.string().nullable();
-    expect(generateExample(schema, false)).toBe("example nullable string");
+    expect(generateExample(schema, false, false)).toBe("example nullable string");
+    expect(generateExample(z.undefined().nullable(), false, false)).toBe(null);
   });
 
   it("should return undefined from an optional zod string", () => {
     const schema = z.string().optional();
-    expect(generateExample(schema, true)).toBe(undefined);
+    expect(generateExample(schema, true, false)).toBe(undefined);
   });
 
   it("should generate an example from a zod array", () => {
-    expect(generateExample(z.string().array(), true)).toStrictEqual(["example string"]);
-    expect(generateExample(z.number().array(), true)).toStrictEqual([1]);
-    expect(generateExample(z.array(z.union([z.string(), z.number()])), true)).toStrictEqual(["example string", 1]);
+    expect(generateExample(z.string().array(), true, false)).toStrictEqual(["example string"]);
+    expect(generateExample(z.number().array(), true, false)).toStrictEqual([1]);
+    expect(generateExample(z.array(z.union([z.string(), z.number()])), true, false)).toStrictEqual(["example string", 1]);
   });
 
   it("should generate an example from a zod union", () => {
     const schema = z.union([z.string(), z.number()]);
-    expect(generateExample(schema, true)).toBe("example string");
+    expect(generateExample(schema, true, false)).toBe("example string");
     const emptyUnion = z.union([] as unknown as [ZodType, ZodType]);
-    expect(generateExample(emptyUnion, true)).toBe(undefined);
+    expect(generateExample(emptyUnion, true, false)).toBe(undefined);
   });
 
-  it("should throw an error from an unknown zod schema", () => {
+  it("should throw an error for an unknown zod schema with strict option", () => {
     const schema = z.unknown();
-    expect(() => generateExample(schema, false)).toThrow("Unknown zod schema");
+    expect(() => generateExample(schema, false, true)).toThrow("Unknown zod schema");
+  });
+
+  it("should return for an unknown zod schema without strict option", () => {
+    const schema = z.unknown();
+    expect(generateExample(schema, false, false)).toBe(undefined);
   });
 });

src/utils/generateExample.ts

@@ -8,6 +8,7 @@ type ExampleGeneratorOptions = {
 export default function generateExample<I, O>(
   schema: ZodType<O, ZodTypeDef, I>,
   ignoreOptionals: boolean,
+  strict: boolean,
   generatorOptions: ExampleGeneratorOptions = { nullable: false },
 ): O {
   if ("defaultValue" in schema._def && typeof schema._def.defaultValue === "function") {
@@ -18,15 +19,17 @@ export default function generateExample<I, O>(
     if (ignoreOptionals) {
       return undefined as unknown as O;
     }
-    return generateExample(innerSchema, ignoreOptionals, generatorOptions);
+    return generateExample(innerSchema, ignoreOptionals, strict, generatorOptions);
   }
   if (schema instanceof ZodNullable) {
     const innerSchema = schema.unwrap();
-    return (generateExample(innerSchema, ignoreOptionals, { ...generatorOptions, nullable: true }) ?? null) as unknown as O;
+    const innerExample = generateExample(innerSchema, ignoreOptionals, strict, { ...generatorOptions, nullable: true });
+    return (innerExample ?? null) as unknown as O;
   }
   if (schema instanceof ZodObject) {
     const entries = Object.entries(schema.shape).map(([keyName, childSchema]) => {
-      return [keyName, generateExample(childSchema as ZodType, ignoreOptionals, { ...generatorOptions, keyName })] as const;
+      const childExample = generateExample(childSchema as ZodType, ignoreOptionals, strict, { ...generatorOptions, keyName });
+      return [keyName, childExample] as const;
     }).filter(([_, value]) => typeof value !== "undefined");
     return Object.fromEntries(entries) as unknown as O;
   }
@@ -106,17 +109,20 @@ export default function generateExample<I, O>(
   if (schema instanceof ZodArray) {
     if (schema._def.type instanceof ZodUnion) {
       const unionOptions = schema._def.type.options as ZodType[];
-      return unionOptions.map(o => generateExample(o, ignoreOptionals, generatorOptions)) as unknown as O;
+      return unionOptions.map(o => generateExample(o, ignoreOptionals, strict, generatorOptions)) as unknown as O;
     }
-    return [generateExample(schema._def.type, ignoreOptionals, generatorOptions)] as unknown as O;
+    return [generateExample(schema._def.type, ignoreOptionals, strict, generatorOptions)] as unknown as O;
   }
   if (schema instanceof ZodUnion) {
     const unionOptions = schema.options as ZodType[];
     const firstItem = unionOptions[0];
     if (firstItem) {
-      return generateExample(firstItem, ignoreOptionals, generatorOptions);
+      return generateExample(firstItem, ignoreOptionals, strict, generatorOptions);
     }
     return undefined as unknown as O;
   }
-  throw new Error("Unknown zod schema");
+  if (strict) {
+    throw new Error("Unknown zod schema");
+  }
+  return undefined as unknown as O;
 }