@davars/graphql-codegen-zod 0.2.1 → 0.3.0

package/dist/zod.d.ts

@@ -6,11 +6,24 @@ import { BaseSchemaVisitor } from './schema_visitor.js';
 export declare class ZodSchemaVisitor extends BaseSchemaVisitor {
     private resolvedTransforms;
     private usedTransformImports;
+    /** GraphQL type names whose schemas had annotations dropped (divergent output types). */
+    private droppedAnnotationTypes;
+    /** Whether the definedNonNullAnySchema fallback was referenced during generation. */
+    private usedAnySchema;
+    /** Called by zod4Scalar when the anySchema fallback is used. */
+    markAnySchemaUsed(): void;
     constructor(schema: GraphQLSchema, config: ValidationSchemaPluginConfig, resolvedTransforms?: Record<string, ResolvedTransform>);
     private addTransformImport;
     buildImports(): string[];
     private getTransformForGraphQLName;
     private hasTransformedFieldRef;
+    /**
+     * Check if any field references a type whose schema output diverges from the
+     * TypeScript type. This includes direct custom scalar fields (e.g. z.coerce.date()
+     * outputs Date but TS says string) and transitive references to types that already
+     * had their annotations dropped.
+     */
+    private hasDivergentFieldRef;
     importValidationSchema(): string;
     initialEmit(): string;
     get InputObjectTypeDefinition(): {

package/dist/zod.js

@@ -8,6 +8,14 @@ const anySchema = `definedNonNullAnySchema`;
 export class ZodSchemaVisitor extends BaseSchemaVisitor {
     resolvedTransforms;
     usedTransformImports = new Map();
+    /** GraphQL type names whose schemas had annotations dropped (divergent output types). */
+    droppedAnnotationTypes = new Set();
+    /** Whether the definedNonNullAnySchema fallback was referenced during generation. */
+    usedAnySchema = false;
+    /** Called by zod4Scalar when the anySchema fallback is used. */
+    markAnySchemaUsed() {
+        this.usedAnySchema = true;
+    }
     constructor(schema, config, resolvedTransforms = {}) {
         super(schema, config);
         this.resolvedTransforms = resolvedTransforms;
@@ -18,6 +26,8 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
         this.usedTransformImports.set(transform.importPath, existing);
     }
     buildImports() {
+        // Filter out types whose annotations were dropped (they'd be imported but unused)
+        this.importTypes = this.importTypes.filter(t => !this.droppedAnnotationTypes.has(t));
         const baseImports = super.buildImports();
         const transformImports = Array.from(this.usedTransformImports.entries())
             .map(([modulePath, symbols]) => `import { ${Array.from(symbols).sort().join(', ')} } from '${modulePath}'`);
@@ -36,34 +46,54 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
             return type.kind === Kind.NAMED_TYPE && this.resolvedTransforms[type.name.value] !== undefined;
         });
     }
+    /**
+     * Check if any field references a type whose schema output diverges from the
+     * TypeScript type. This includes direct custom scalar fields (e.g. z.coerce.date()
+     * outputs Date but TS says string) and transitive references to types that already
+     * had their annotations dropped.
+     */
+    hasDivergentFieldRef(fields) {
+        if (!fields)
+            return false;
+        return fields.some((field) => {
+            let type = field.type;
+            while (type.kind === Kind.NON_NULL_TYPE || type.kind === Kind.LIST_TYPE)
+                type = type.type;
+            if (type.kind !== Kind.NAMED_TYPE)
+                return false;
+            const name = type.name.value;
+            return (this.config.scalarSchemas?.[name] !== undefined) || this.droppedAnnotationTypes.has(name);
+        });
+    }
     importValidationSchema() {
         return `import * as z from 'zod'`;
     }
     initialEmit() {
-        return (`\n${[
+        const blocks = [
             new DeclarationBlock({})
                 .asKind('type')
                 .withName('Properties<T>')
                 .withContent(['Required<{', '  [K in keyof T]: z.ZodType<T[K], T[K]>;', '}>'].join('\n'))
                 .string,
+        ];
+        if (this.usedAnySchema) {
             // Unfortunately, zod doesn't provide non-null defined any schema.
             // This is a temporary hack until it is fixed.
             // see: https://github.com/colinhacks/zod/issues/884
-            new DeclarationBlock({}).asKind('type').withName('definedNonNullAny').withContent('{}').string,
-            new DeclarationBlock({})
+            blocks.push(new DeclarationBlock({}).asKind('type').withName('definedNonNullAny').withContent('{}').string, new DeclarationBlock({})
                 .export()
                 .asKind('const')
                 .withName(`isDefinedNonNullAny`)
                 .withContent(`(v: any): v is definedNonNullAny => v !== undefined && v !== null`)
-                .string,
-            new DeclarationBlock({})
+                .string, new DeclarationBlock({})
                 .export()
                 .asKind('const')
                 .withName(`${anySchema}`)
                 .withContent(`z.any().refine((v) => isDefinedNonNullAny(v))`)
-                .string,
-            ...this.enumDeclarations,
-        ].join('\n')}`);
+                .string);
+        }
+        blocks.push(...this.enumDeclarations);
+        return `\n${blocks.join('\n')}`;
     }
     get InputObjectTypeDefinition() {
         return {
@@ -90,9 +120,11 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
                 const argumentBlocks = this.buildTypeDefinitionArguments(node, visitor);
                 const appendArguments = argumentBlocks ? `\n${argumentBlocks}` : '';
                 // Building schema for fields.
-                const shape = node.fields?.map(field => generateFieldZodSchema(this.config, visitor, field, 2)).join(',\n');
+                const shape = node.fields?.map(field => generateFieldZodSchema(this.config, visitor, field, 2, this)).join(',\n');
                 const transformSuffix = transform ? `.transform(${transform.symbolName})` : '';
-                const dropAnnotation = !!transform || this.hasTransformedFieldRef(node.fields);
+                const dropAnnotation = !!transform || this.hasTransformedFieldRef(node.fields) || this.hasDivergentFieldRef(node.fields);
+                if (dropAnnotation)
+                    this.droppedAnnotationTypes.add(node.name.value);
                 const schemaName = dropAnnotation
                     ? `${name}Schema`
                     : `${name}Schema: z.ZodObject<Properties<${typeName}>>`;
@@ -131,12 +163,14 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
                 const argumentBlocks = this.buildTypeDefinitionArguments(node, visitor);
                 const appendArguments = argumentBlocks ? `\n${argumentBlocks}` : '';
                 // Building schema for fields.
-                const shape = node.fields?.map(field => generateFieldZodSchema(this.config, visitor, field, 2)).join(',\n');
+                const shape = node.fields?.map(field => generateFieldZodSchema(this.config, visitor, field, 2, this)).join(',\n');
                 const transformSuffix = transform ? `.transform(${transform.symbolName})` : '';
                 // Drop the explicit type annotation when a transform is applied (changes
                 // return type from ZodObject to ZodPipe) or when any field references a
                 // transformed type (input/output types diverge, breaking Properties<T>).
-                const dropAnnotation = !!transform || this.hasTransformedFieldRef(node.fields);
+                const dropAnnotation = !!transform || this.hasTransformedFieldRef(node.fields) || this.hasDivergentFieldRef(node.fields);
+                if (dropAnnotation)
+                    this.droppedAnnotationTypes.add(node.name.value);
                 const schemaName = dropAnnotation
                     ? `${name}Schema`
                     : `${name}Schema: z.ZodObject<Properties<${typeName}>>`;
@@ -148,7 +182,7 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
                             .withName(schemaName)
                             .withContent([
                             `z.object({`,
-                            indent(`__typename: z.literal('${node.name.value}').optional(),`, 2),
+                            indent(`__typename: z.literal('${node.name.value}'),`, 2),
                             shape,
                             `})${transformSuffix}`,
                         ].join('\n'))
@@ -161,7 +195,7 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
                             .withName(dropAnnotation ? `${name}Schema()` : `${name}Schema(): z.ZodObject<Properties<${typeName}>>`)
                             .withBlock([
                             indent(`return z.object({`),
-                            indent(`__typename: z.literal('${node.name.value}').optional(),`, 2),
+                            indent(`__typename: z.literal('${node.name.value}'),`, 2),
                             shape,
                             indent(`})${transformSuffix}`),
                         ].join('\n'))
@@ -228,13 +262,15 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
     }
     buildInputFields(fields, visitor, name, graphqlName) {
         const typeName = visitor.prefixTypeNamespace(name);
-        const shape = fields.map(field => generateFieldZodSchema(this.config, visitor, field, 2)).join(',\n');
+        const shape = fields.map(field => generateFieldZodSchema(this.config, visitor, field, 2, this)).join(',\n');
         const transform = graphqlName ? this.getTransformForGraphQLName(graphqlName) : undefined;
         if (transform) {
             this.addTransformImport(transform);
         }
         const transformSuffix = transform ? `.transform(${transform.symbolName})` : '';
-        const dropAnnotation = !!transform || this.hasTransformedFieldRef(fields);
+        const dropAnnotation = !!transform || this.hasTransformedFieldRef(fields) || this.hasDivergentFieldRef(fields);
+        if (dropAnnotation && graphqlName)
+            this.droppedAnnotationTypes.add(graphqlName);
         const schemaName = dropAnnotation
             ? `${name}Schema`
             : `${name}Schema: z.ZodObject<Properties<${typeName}>>`;
@@ -257,13 +293,13 @@ export class ZodSchemaVisitor extends BaseSchemaVisitor {
         }
     }
 }
-function generateFieldZodSchema(config, visitor, field, indentCount) {
-    const gen = generateFieldTypeZodSchema(config, visitor, field, field.type);
+function generateFieldZodSchema(config, visitor, field, indentCount, schemaVisitor) {
+    const gen = generateFieldTypeZodSchema(config, visitor, field, field.type, undefined, schemaVisitor);
     return indent(`${field.name.value}: ${maybeLazy(visitor, field.type, gen)}`, indentCount);
 }
-function generateFieldTypeZodSchema(config, visitor, field, type, parentType) {
+function generateFieldTypeZodSchema(config, visitor, field, type, parentType, schemaVisitor) {
     if (isListType(type)) {
-        const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type);
+        const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type, schemaVisitor);
         if (!isNonNullType(parentType)) {
             const arrayGen = `z.array(${maybeLazy(visitor, type.type, gen)})`;
             const maybeLazyGen = applyDirectives(config, field, arrayGen);
@@ -272,11 +308,11 @@ function generateFieldTypeZodSchema(config, visitor, field, type, parentType) {
         return `z.array(${maybeLazy(visitor, type.type, gen)})`;
     }
     if (isNonNullType(type)) {
-        const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type);
+        const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type, schemaVisitor);
         return maybeLazy(visitor, type.type, gen);
     }
     if (isNamedType(type)) {
-        const gen = generateNameNodeZodSchema(config, visitor, type.name);
+        const gen = generateNameNodeZodSchema(config, visitor, type.name, schemaVisitor);
         if (isListType(parentType))
             return `${gen}.nullable()`;
         let appliedDirectivesGen = applyDirectives(config, field, gen);
@@ -315,7 +351,7 @@ function applyDirectives(config, field, gen) {
     }
     return gen;
 }
-function generateNameNodeZodSchema(config, visitor, node) {
+function generateNameNodeZodSchema(config, visitor, node, schemaVisitor) {
     const converter = visitor.getNameNodeConverter(node);
     switch (converter?.targetKind) {
         case 'InterfaceTypeDefinition':
@@ -333,11 +369,11 @@ function generateNameNodeZodSchema(config, visitor, node) {
         case 'EnumTypeDefinition':
             return `${converter.convertName()}Schema`;
         case 'ScalarTypeDefinition':
-            return zod4Scalar(config, visitor, node.value);
+            return zod4Scalar(config, visitor, node.value, schemaVisitor);
         default:
             if (converter?.targetKind)
                 console.warn('Unknown targetKind', converter?.targetKind);
-            return zod4Scalar(config, visitor, node.value);
+            return zod4Scalar(config, visitor, node.value, schemaVisitor);
     }
 }
 function maybeLazy(visitor, type, schema) {
@@ -348,7 +384,7 @@ function maybeLazy(visitor, type, schema) {
     const isComplexType = !isScalarType(schemaType) && !isEnumType(schemaType);
     return isComplexType ? `z.lazy(() => ${schema})` : schema;
 }
-function zod4Scalar(config, visitor, scalarName) {
+function zod4Scalar(config, visitor, scalarName, schemaVisitor) {
     if (config.scalarSchemas?.[scalarName])
         return config.scalarSchemas[scalarName];
     const tsType = visitor.getScalarType(scalarName);
@@ -364,5 +400,6 @@ function zod4Scalar(config, visitor, scalarName) {
         return config.defaultScalarTypeSchema;
     }
     console.warn('unhandled scalar name:', scalarName);
+    schemaVisitor?.markAnySchemaUsed();
     return anySchema;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davars/graphql-codegen-zod",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "GraphQL Code Generator plugin that generates Zod v4 validation schemas with transform support",
   "type": "module",
   "license": "MIT",
@@ -13,13 +13,15 @@
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
-      }
+      },
+      "default": "./dist/index.js"
     },
     "./config": {
       "import": {
         "types": "./dist/transform_config.d.ts",
         "default": "./dist/transform_config.js"
-      }
+      },
+      "default": "./dist/transform_config.js"
     }
   },
   "main": "dist/index.js",