fix #907 for zodv4

Author: Code-Hex

src/zodv4/index.ts

@@ -16,13 +16,14 @@ import type { Visitor } from '../visitor.js';
 import { resolveExternalModuleAndFn } from '@graphql-codegen/plugin-helpers';
 import { convertNameParts, DeclarationBlock, indent } from '@graphql-codegen/visitor-plugin-common';
 import {
+  isEnumType,
+  isScalarType,
   Kind,
 } from 'graphql';
 import { buildApi, formatDirectiveConfig } from '../directive.js';
 import {
   escapeGraphQLCharacters,
   InterfaceTypeDefinitionBuilder,
-  isInput,
   isListType,
   isNamedType,
   isNonNullType,
@@ -275,22 +276,22 @@ export class ZodV4SchemaVisitor extends BaseSchemaVisitor {
 
 function generateFieldZodSchema(config: ValidationSchemaPluginConfig, visitor: Visitor, field: InputValueDefinitionNode | FieldDefinitionNode, indentCount: number): string {
   const gen = generateFieldTypeZodSchema(config, visitor, field, field.type);
-  return indent(`${field.name.value}: ${maybeLazy(field.type, gen)}`, indentCount);
+  return indent(`${field.name.value}: ${maybeLazy(visitor, field.type, gen)}`, indentCount);
 }
 
 function generateFieldTypeZodSchema(config: ValidationSchemaPluginConfig, visitor: Visitor, field: InputValueDefinitionNode | FieldDefinitionNode, type: TypeNode, parentType?: TypeNode): string {
   if (isListType(type)) {
     const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type);
     if (!isNonNullType(parentType)) {
-      const arrayGen = `z.array(${maybeLazy(type.type, gen)})`;
+      const arrayGen = `z.array(${maybeLazy(visitor, type.type, gen)})`;
       const maybeLazyGen = applyDirectives(config, field, arrayGen);
       return `${maybeLazyGen}.nullish()`;
     }
-    return `z.array(${maybeLazy(type.type, gen)})`;
+    return `z.array(${maybeLazy(visitor, type.type, gen)})`;
   }
   if (isNonNullType(type)) {
     const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type);
-    return maybeLazy(type.type, gen);
+    return maybeLazy(visitor, type.type, gen);
   }
   if (isNamedType(type)) {
     const gen = generateNameNodeZodSchema(config, visitor, type.name);
@@ -371,11 +372,14 @@ function generateNameNodeZodSchema(config: ValidationSchemaPluginConfig, visitor
   }
 }
 
-function maybeLazy(type: TypeNode, schema: string): string {
-  if (isNamedType(type) && isInput(type.name.value))
-    return `z.lazy(() => ${schema})`;
+function maybeLazy(visitor: Visitor, type: TypeNode, schema: string): string {
+  if (!isNamedType(type)) {
+    return schema;
+  }
 
-  return schema;
+  const schemaType = visitor.getType(type.name.value);
+  const isComplexType = !isScalarType(schemaType) && !isEnumType(schemaType);
+  return isComplexType ? `z.lazy(() => ${schema})` : schema;
 }
 
 function zod4Scalar(config: ValidationSchemaPluginConfig, visitor: Visitor, scalarName: string): string {

tests/zodv4.spec.ts

@@ -1336,15 +1336,15 @@ describe('zodv4', () => {
         export function BookSchema(): z.ZodObject<Properties<Book>> {
           return z.object({
             __typename: z.literal('Book').optional(),
-            author: AuthorSchema().nullish(),
+            author: z.lazy(() => AuthorSchema().nullish()),
             title: z.string().nullish()
           })
         }
 
         export function AuthorSchema(): z.ZodObject<Properties<Author>> {
           return z.object({
             __typename: z.literal('Author').optional(),
-            books: z.array(BookSchema().nullable()).nullish(),
+            books: z.array(z.lazy(() => BookSchema().nullable())).nullish(),
             name: z.string().nullish()
           })
         }
@@ -1621,7 +1621,7 @@ describe('zodv4', () => {
         export function GeometrySchema(): z.ZodObject<Properties<Geometry>> {
           return z.object({
             __typename: z.literal('Geometry').optional(),
-            shape: ShapeSchema().nullish()
+            shape: z.lazy(() => ShapeSchema().nullish())
           })
         }
         "
@@ -1772,7 +1772,7 @@ describe('zodv4', () => {
 
         export const GeometrySchema: z.ZodObject<Properties<Geometry>> = z.object({
             __typename: z.literal('Geometry').optional(),
-            shape: ShapeSchema.nullish()
+            shape: z.lazy(() => ShapeSchema.nullish())
         });
         "
       `)
@@ -1924,14 +1924,14 @@ describe('zodv4', () => {
 
           export function BookSchema(): z.ZodObject<Properties<Book>> {
             return z.object({
-              author: AuthorSchema().nullish(),
+              author: z.lazy(() => AuthorSchema().nullish()),
               title: z.string().nullish()
             })
           }
 
           export function AuthorSchema(): z.ZodObject<Properties<Author>> {
             return z.object({
-              books: z.array(BookSchema().nullable()).nullish(),
+              books: z.array(z.lazy(() => BookSchema().nullable())).nullish(),
               name: z.string().nullish()
             })
           }
@@ -1987,15 +1987,15 @@ describe('zodv4', () => {
           export function BookSchema(): z.ZodObject<Properties<Book>> {
             return z.object({
               title: z.string(),
-              author: AuthorSchema()
+              author: z.lazy(() => AuthorSchema())
             })
           }
 
           export function TextbookSchema(): z.ZodObject<Properties<Textbook>> {
             return z.object({
               __typename: z.literal('Textbook').optional(),
               title: z.string(),
-              author: AuthorSchema(),
+              author: z.lazy(() => AuthorSchema()),
               courses: z.array(z.string())
             })
           }
@@ -2004,15 +2004,15 @@ describe('zodv4', () => {
             return z.object({
               __typename: z.literal('ColoringBook').optional(),
               title: z.string(),
-              author: AuthorSchema(),
+              author: z.lazy(() => AuthorSchema()),
               colors: z.array(z.string())
             })
           }
 
           export function AuthorSchema(): z.ZodObject<Properties<Author>> {
             return z.object({
               __typename: z.literal('Author').optional(),
-              books: z.array(BookSchema()).nullish(),
+              books: z.array(z.lazy(() => BookSchema())).nullish(),
               name: z.string().nullish()
             })
           }