@davars/graphql-codegen-zod 0.1.0

package/dist/transforms.js

@@ -0,0 +1,137 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+/**
+ * Loads and resolves transform configuration using pure static analysis.
+ *
+ * Parses the TypeScript config file's AST to extract:
+ * 1. Import declarations → symbol name to module path mapping
+ * 2. Default export object → GraphQL type name to symbol name mapping
+ * 3. Rebased import paths → adjusted for the output file location
+ */
+export function loadTransforms(configPath, outputPath) {
+    const absoluteConfigPath = path.resolve(configPath);
+    const configSource = fs.readFileSync(absoluteConfigPath, 'utf-8');
+    const sourceFile = ts.createSourceFile(absoluteConfigPath, configSource, ts.ScriptTarget.Latest, true);
+    // Step 1: symbol name → module path (from import declarations)
+    const importMap = extractImportMap(sourceFile);
+    // Step 2: type name → symbol name (from default export object)
+    const typeMap = extractDefaultExportMap(sourceFile);
+    // Step 3: combine and rebase paths
+    const result = {};
+    for (const [typeName, symbolName] of typeMap) {
+        const importPath = importMap.get(symbolName);
+        if (!importPath) {
+            throw new Error(`Transform for '${typeName}': could not resolve import path for '${symbolName}'. `
+                + `Ensure it is a named function imported in the config file.`);
+        }
+        result[typeName] = {
+            symbolName,
+            importPath: rebasePath(importPath, absoluteConfigPath, outputPath),
+        };
+    }
+    return result;
+}
+/**
+ * Extracts a map of imported symbol names to their module paths.
+ * Skips `import type` declarations since we need value imports.
+ */
+export function extractImportMap(sourceFile) {
+    const map = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isImportDeclaration(stmt) || !stmt.importClause?.namedBindings)
+            continue;
+        // Skip `import type` — we only care about value imports
+        if (stmt.importClause.isTypeOnly)
+            continue;
+        const modulePath = stmt.moduleSpecifier.text;
+        if (ts.isNamedImports(stmt.importClause.namedBindings)) {
+            for (const element of stmt.importClause.namedBindings.elements) {
+                if (!element.isTypeOnly) {
+                    map.set(element.name.text, modulePath);
+                }
+            }
+        }
+    }
+    return map;
+}
+/**
+ * Extracts the default export object literal, mapping property names to
+ * their identifier values (the imported symbol names).
+ *
+ * Supports these patterns:
+ *   export default { TypeName: transformFn }
+ *   const config = { TypeName: transformFn }; export default config;
+ */
+export function extractDefaultExportMap(sourceFile) {
+    const map = new Map();
+    // Collect top-level variable declarations for resolving `export default config`
+    const varDecls = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && decl.initializer) {
+                    varDecls.set(decl.name.text, decl.initializer);
+                }
+            }
+        }
+    }
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isExportAssignment(stmt) || stmt.isExportEquals)
+            continue;
+        let expr = stmt.expression;
+        // Handle `export default config` where config is a variable
+        if (ts.isIdentifier(expr)) {
+            const resolved = varDecls.get(expr.text);
+            if (resolved) {
+                expr = resolved;
+            }
+        }
+        // Handle satisfies: `export default { ... } satisfies TransformConfig`
+        if (ts.isSatisfiesExpression(expr)) {
+            expr = expr.expression;
+        }
+        // Handle `as` cast: `export default { ... } as TransformConfig`
+        if (ts.isAsExpression(expr)) {
+            expr = expr.expression;
+        }
+        if (ts.isObjectLiteralExpression(expr)) {
+            extractObjectProperties(expr, map);
+        }
+    }
+    return map;
+}
+function extractObjectProperties(obj, map) {
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const key = ts.isIdentifier(prop.name)
+            ? prop.name.text
+            : ts.isStringLiteral(prop.name)
+                ? prop.name.text
+                : undefined;
+        if (!key)
+            continue;
+        if (ts.isIdentifier(prop.initializer)) {
+            map.set(key, prop.initializer.text);
+        }
+        else {
+            throw new Error(`Transform for '${key}' must be an imported named function, not an inline definition. `
+                + `Import the function and reference it by name.`);
+        }
+    }
+}
+/**
+ * Adjusts a relative import path so it's correct relative to the output file
+ * rather than the config file. Non-relative paths (aliases, packages) pass through unchanged.
+ */
+export function rebasePath(importPath, configPath, outputPath) {
+    // Only rebase relative paths — leave aliases and package imports as-is
+    if (!importPath.startsWith('.'))
+        return importPath;
+    const configDir = path.dirname(path.resolve(configPath));
+    const outputDir = path.dirname(path.resolve(outputPath));
+    const absoluteTarget = path.resolve(configDir, importPath);
+    const rebased = path.relative(outputDir, absoluteTarget);
+    return rebased.startsWith('.') ? rebased : `./${rebased}`;
+}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+import type { ASTNode, ASTVisitFn } from 'graphql';
+export type NewVisitor = Partial<{
+    readonly [NodeT in ASTNode as NodeT['kind']]?: {
+        leave?: ASTVisitFn<NodeT>;
+    };
+}>;
+export interface SchemaVisitor extends NewVisitor {
+    buildImports: () => string[];
+    initialEmit: () => string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/visitor.d.ts

@@ -0,0 +1,19 @@
+import type { FieldDefinitionNode, GraphQLSchema, InterfaceTypeDefinitionNode, NameNode, ObjectTypeDefinitionNode } from 'graphql';
+import type { ValidationSchemaPluginConfig } from './config.js';
+import { TsVisitor } from '@graphql-codegen/typescript';
+export declare class Visitor extends TsVisitor {
+    private scalarDirection;
+    private schema;
+    private pluginConfig;
+    constructor(scalarDirection: 'input' | 'output' | 'both', schema: GraphQLSchema, pluginConfig: ValidationSchemaPluginConfig);
+    prefixTypeNamespace(type: string): string;
+    private isSpecifiedScalarName;
+    getType(name: string): import("graphql").GraphQLNamedType | undefined;
+    getNameNodeConverter(node: NameNode): {
+        targetKind: import("graphql").Kind.SCALAR_TYPE_DEFINITION | import("graphql").Kind.OBJECT_TYPE_DEFINITION | import("graphql").Kind.INTERFACE_TYPE_DEFINITION | import("graphql").Kind.UNION_TYPE_DEFINITION | import("graphql").Kind.ENUM_TYPE_DEFINITION | import("graphql").Kind.INPUT_OBJECT_TYPE_DEFINITION;
+        convertName: () => string;
+    } | undefined;
+    getScalarType(scalarName: string): string | null;
+    shouldEmitAsNotAllowEmptyString(name: string): boolean;
+    buildArgumentsSchemaBlock(node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode, callback: (typeName: string, field: FieldDefinitionNode) => string): string | undefined;
+}

package/dist/visitor.js

@@ -0,0 +1,68 @@
+import { TsVisitor } from '@graphql-codegen/typescript';
+import { specifiedScalarTypes, } from 'graphql';
+export class Visitor extends TsVisitor {
+    scalarDirection;
+    schema;
+    pluginConfig;
+    constructor(scalarDirection, schema, pluginConfig) {
+        super(schema, pluginConfig);
+        this.scalarDirection = scalarDirection;
+        this.schema = schema;
+        this.pluginConfig = pluginConfig;
+    }
+    prefixTypeNamespace(type) {
+        if (this.pluginConfig.importFrom && this.pluginConfig.schemaNamespacedImportName) {
+            return `${this.pluginConfig.schemaNamespacedImportName}.${type}`;
+        }
+        return type;
+    }
+    isSpecifiedScalarName(scalarName) {
+        return specifiedScalarTypes.some(({ name }) => name === scalarName);
+    }
+    getType(name) {
+        return this.schema.getType(name);
+    }
+    getNameNodeConverter(node) {
+        const typ = this.schema.getType(node.value);
+        const astNode = typ?.astNode;
+        if (astNode === undefined || astNode === null)
+            return undefined;
+        return {
+            targetKind: astNode.kind,
+            convertName: () => this.convertName(astNode.name.value),
+        };
+    }
+    getScalarType(scalarName) {
+        if (this.scalarDirection === 'both')
+            return null;
+        const scalar = this.scalars[scalarName];
+        if (!scalar)
+            throw new Error(`Unknown scalar ${scalarName}`);
+        return scalar[this.scalarDirection];
+    }
+    shouldEmitAsNotAllowEmptyString(name) {
+        if (this.pluginConfig.notAllowEmptyString !== true)
+            return false;
+        const typ = this.getType(name);
+        if (typ?.astNode?.kind !== 'ScalarTypeDefinition' && !this.isSpecifiedScalarName(name))
+            return false;
+        const tsType = this.getScalarType(name);
+        return tsType === 'string';
+    }
+    buildArgumentsSchemaBlock(node, callback) {
+        const fieldsWithArguments = node.fields?.filter(field => field.arguments && field.arguments.length > 0) ?? [];
+        if (fieldsWithArguments.length === 0)
+            return undefined;
+        return fieldsWithArguments
+            .map((field) => {
+            const name = `${this.convertName(node.name.value)
+                + (this.config.addUnderscoreToArgsType ? '_' : '')
+                + this.convertName(field, {
+                    useTypesPrefix: false,
+                    useTypesSuffix: false,
+                })}Args`;
+            return callback(name, field);
+        })
+            .join('\n');
+    }
+}

package/dist/zod.d.ts

@@ -0,0 +1,32 @@
+import type { EnumTypeDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode, UnionTypeDefinitionNode } from 'graphql';
+import type { ValidationSchemaPluginConfig } from './config.js';
+import type { ResolvedTransform } from './transforms.js';
+import type { Visitor } from './visitor.js';
+import { BaseSchemaVisitor } from './schema_visitor.js';
+export declare class ZodSchemaVisitor extends BaseSchemaVisitor {
+    private resolvedTransforms;
+    private usedTransformImports;
+    constructor(schema: GraphQLSchema, config: ValidationSchemaPluginConfig, resolvedTransforms?: Record<string, ResolvedTransform>);
+    private addTransformImport;
+    buildImports(): string[];
+    private getTransformForGraphQLName;
+    private hasTransformedFieldRef;
+    importValidationSchema(): string;
+    initialEmit(): string;
+    get InputObjectTypeDefinition(): {
+        leave: (node: InputObjectTypeDefinitionNode) => string;
+    };
+    get InterfaceTypeDefinition(): {
+        leave: ((node: InterfaceTypeDefinitionNode) => any) | undefined;
+    };
+    get ObjectTypeDefinition(): {
+        leave: ((node: ObjectTypeDefinitionNode) => any) | undefined;
+    };
+    get EnumTypeDefinition(): {
+        leave: (node: EnumTypeDefinitionNode) => void;
+    };
+    get UnionTypeDefinition(): {
+        leave: (node: UnionTypeDefinitionNode) => string | undefined;
+    };
+    protected buildInputFields(fields: readonly (FieldDefinitionNode | InputValueDefinitionNode)[], visitor: Visitor, name: string, graphqlName?: string): string;
+}

package/dist/zod.js

@@ -0,0 +1,368 @@
+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, isListType, isNamedType, isNonNullType, ObjectTypeDefinitionBuilder, } from './graphql.js';
+import { BaseSchemaVisitor } from './schema_visitor.js';
+const anySchema = `definedNonNullAnySchema`;
+export class ZodSchemaVisitor extends BaseSchemaVisitor {
+    resolvedTransforms;
+    usedTransformImports = new Map();
+    constructor(schema, config, resolvedTransforms = {}) {
+        super(schema, config);
+        this.resolvedTransforms = resolvedTransforms;
+    }
+    addTransformImport(transform) {
+        const existing = this.usedTransformImports.get(transform.importPath) ?? new Set();
+        existing.add(transform.symbolName);
+        this.usedTransformImports.set(transform.importPath, existing);
+    }
+    buildImports() {
+        const baseImports = super.buildImports();
+        const transformImports = Array.from(this.usedTransformImports.entries())
+            .map(([modulePath, symbols]) => `import { ${Array.from(symbols).sort().join(', ')} } from '${modulePath}'`);
+        return [...baseImports, ...transformImports];
+    }
+    getTransformForGraphQLName(graphqlName) {
+        return this.resolvedTransforms[graphqlName];
+    }
+    hasTransformedFieldRef(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;
+            return type.kind === Kind.NAMED_TYPE && this.resolvedTransforms[type.name.value] !== undefined;
+        });
+    }
+    importValidationSchema() {
+        return `import * as z from 'zod'`;
+    }
+    initialEmit() {
+        return (`\n${[
+            new DeclarationBlock({})
+                .asKind('type')
+                .withName('Properties<T>')
+                .withContent(['Required<{', '  [K in keyof T]: z.ZodType<T[K], T[K]>;', '}>'].join('\n'))
+                .string,
+            // 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({})
+                .export()
+                .asKind('const')
+                .withName(`isDefinedNonNullAny`)
+                .withContent(`(v: any): v is definedNonNullAny => v !== undefined && v !== null`)
+                .string,
+            new DeclarationBlock({})
+                .export()
+                .asKind('const')
+                .withName(`${anySchema}`)
+                .withContent(`z.any().refine((v) => isDefinedNonNullAny(v))`)
+                .string,
+            ...this.enumDeclarations,
+        ].join('\n')}`);
+    }
+    get InputObjectTypeDefinition() {
+        return {
+            leave: (node) => {
+                const visitor = this.createVisitor('input');
+                const name = visitor.convertName(node.name.value);
+                this.importTypes.push(name);
+                return this.buildInputFields(node.fields ?? [], visitor, name, node.name.value);
+            },
+        };
+    }
+    get InterfaceTypeDefinition() {
+        return {
+            leave: InterfaceTypeDefinitionBuilder(this.config.withObjectType, (node) => {
+                const visitor = this.createVisitor('output');
+                const name = visitor.convertName(node.name.value);
+                const typeName = visitor.prefixTypeNamespace(name);
+                this.importTypes.push(name);
+                const transform = this.getTransformForGraphQLName(node.name.value);
+                if (transform) {
+                    this.addTransformImport(transform);
+                }
+                // Building schema for field arguments.
+                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 transformSuffix = transform ? `.transform(${transform.symbolName})` : '';
+                const dropAnnotation = !!transform || this.hasTransformedFieldRef(node.fields);
+                const schemaName = dropAnnotation
+                    ? `${name}Schema`
+                    : `${name}Schema: z.ZodObject<Properties<${typeName}>>`;
+                switch (this.config.validationSchemaExportType) {
+                    case 'const':
+                        return (new DeclarationBlock({})
+                            .export()
+                            .asKind('const')
+                            .withName(schemaName)
+                            .withContent([`z.object({`, shape, `})${transformSuffix}`].join('\n'))
+                            .string + appendArguments);
+                    case 'function':
+                    default:
+                        return (new DeclarationBlock({})
+                            .export()
+                            .asKind('function')
+                            .withName(dropAnnotation ? `${name}Schema()` : `${name}Schema(): z.ZodObject<Properties<${typeName}>>`)
+                            .withBlock([indent(`return z.object({`), shape, indent(`})${transformSuffix}`)].join('\n'))
+                            .string + appendArguments);
+                }
+            }),
+        };
+    }
+    get ObjectTypeDefinition() {
+        return {
+            leave: ObjectTypeDefinitionBuilder(this.config.withObjectType, (node) => {
+                const visitor = this.createVisitor('output');
+                const name = visitor.convertName(node.name.value);
+                const typeName = visitor.prefixTypeNamespace(name);
+                this.importTypes.push(name);
+                const transform = this.getTransformForGraphQLName(node.name.value);
+                if (transform) {
+                    this.addTransformImport(transform);
+                }
+                // Building schema for field arguments.
+                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 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 schemaName = dropAnnotation
+                    ? `${name}Schema`
+                    : `${name}Schema: z.ZodObject<Properties<${typeName}>>`;
+                switch (this.config.validationSchemaExportType) {
+                    case 'const':
+                        return (new DeclarationBlock({})
+                            .export()
+                            .asKind('const')
+                            .withName(schemaName)
+                            .withContent([
+                            `z.object({`,
+                            indent(`__typename: z.literal('${node.name.value}').optional(),`, 2),
+                            shape,
+                            `})${transformSuffix}`,
+                        ].join('\n'))
+                            .string + appendArguments);
+                    case 'function':
+                    default:
+                        return (new DeclarationBlock({})
+                            .export()
+                            .asKind('function')
+                            .withName(dropAnnotation ? `${name}Schema()` : `${name}Schema(): z.ZodObject<Properties<${typeName}>>`)
+                            .withBlock([
+                            indent(`return z.object({`),
+                            indent(`__typename: z.literal('${node.name.value}').optional(),`, 2),
+                            shape,
+                            indent(`})${transformSuffix}`),
+                        ].join('\n'))
+                            .string + appendArguments);
+                }
+            }),
+        };
+    }
+    get EnumTypeDefinition() {
+        return {
+            leave: (node) => {
+                const visitor = this.createVisitor('both');
+                const enumname = visitor.convertName(node.name.value);
+                const enumTypeName = visitor.prefixTypeNamespace(enumname);
+                this.importTypes.push(enumname);
+                // hoist enum declarations
+                this.enumDeclarations.push(new DeclarationBlock({})
+                    .export()
+                    .asKind('const')
+                    .withName(`${enumname}Schema`)
+                    .withContent(this.config.enumsAsTypes
+                    ? `z.enum([${node.values?.map(enumOption => `'${enumOption.name.value}'`).join(', ')}])`
+                    : `z.enum(${enumTypeName})`)
+                    .string);
+            },
+        };
+    }
+    get UnionTypeDefinition() {
+        return {
+            leave: (node) => {
+                if (!node.types || !this.config.withObjectType)
+                    return;
+                const visitor = this.createVisitor('output');
+                const unionName = visitor.convertName(node.name.value);
+                const unionElements = node.types.map((t) => {
+                    const element = visitor.convertName(t.name.value);
+                    const typ = visitor.getType(t.name.value);
+                    if (typ?.astNode?.kind === 'EnumTypeDefinition')
+                        return `${element}Schema`;
+                    switch (this.config.validationSchemaExportType) {
+                        case 'const':
+                            return `${element}Schema`;
+                        case 'function':
+                        default:
+                            return `${element}Schema()`;
+                    }
+                }).join(', ');
+                const unionElementsCount = node.types.length ?? 0;
+                const union = unionElementsCount > 1 ? `z.union([${unionElements}])` : unionElements;
+                switch (this.config.validationSchemaExportType) {
+                    case 'const':
+                        return new DeclarationBlock({}).export().asKind('const').withName(`${unionName}Schema`).withContent(union).string;
+                    case 'function':
+                    default:
+                        return new DeclarationBlock({})
+                            .export()
+                            .asKind('function')
+                            .withName(`${unionName}Schema()`)
+                            .withBlock(indent(`return ${union}`))
+                            .string;
+                }
+            },
+        };
+    }
+    buildInputFields(fields, visitor, name, graphqlName) {
+        const typeName = visitor.prefixTypeNamespace(name);
+        const shape = fields.map(field => generateFieldZodSchema(this.config, visitor, field, 2)).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 schemaName = dropAnnotation
+            ? `${name}Schema`
+            : `${name}Schema: z.ZodObject<Properties<${typeName}>>`;
+        switch (this.config.validationSchemaExportType) {
+            case 'const':
+                return new DeclarationBlock({})
+                    .export()
+                    .asKind('const')
+                    .withName(schemaName)
+                    .withContent([`z.object({`, shape, `})${transformSuffix}`].join('\n'))
+                    .string;
+            case 'function':
+            default:
+                return new DeclarationBlock({})
+                    .export()
+                    .asKind('function')
+                    .withName(dropAnnotation ? `${name}Schema()` : `${name}Schema(): z.ZodObject<Properties<${typeName}>>`)
+                    .withBlock([indent(`return z.object({`), shape, indent(`})${transformSuffix}`)].join('\n'))
+                    .string;
+        }
+    }
+}
+function generateFieldZodSchema(config, visitor, field, indentCount) {
+    const gen = generateFieldTypeZodSchema(config, visitor, field, field.type);
+    return indent(`${field.name.value}: ${maybeLazy(visitor, field.type, gen)}`, indentCount);
+}
+function generateFieldTypeZodSchema(config, visitor, field, type, parentType) {
+    if (isListType(type)) {
+        const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type);
+        if (!isNonNullType(parentType)) {
+            const arrayGen = `z.array(${maybeLazy(visitor, type.type, gen)})`;
+            const maybeLazyGen = applyDirectives(config, field, arrayGen);
+            return `${maybeLazyGen}.nullish()`;
+        }
+        return `z.array(${maybeLazy(visitor, type.type, gen)})`;
+    }
+    if (isNonNullType(type)) {
+        const gen = generateFieldTypeZodSchema(config, visitor, field, type.type, type);
+        return maybeLazy(visitor, type.type, gen);
+    }
+    if (isNamedType(type)) {
+        const gen = generateNameNodeZodSchema(config, visitor, type.name);
+        if (isListType(parentType))
+            return `${gen}.nullable()`;
+        let appliedDirectivesGen = applyDirectives(config, field, gen);
+        if (field.kind === Kind.INPUT_VALUE_DEFINITION) {
+            const { defaultValue } = field;
+            if (defaultValue?.kind === Kind.INT || defaultValue?.kind === Kind.FLOAT || defaultValue?.kind === Kind.BOOLEAN)
+                appliedDirectivesGen = `${appliedDirectivesGen}.default(${defaultValue.value})`;
+            if (defaultValue?.kind === Kind.STRING || defaultValue?.kind === Kind.ENUM) {
+                if (config.useEnumTypeAsDefaultValue && defaultValue?.kind !== Kind.STRING) {
+                    let value = convertNameParts(defaultValue.value, resolveExternalModuleAndFn('change-case-all#pascalCase'), config.namingConvention?.transformUnderscore);
+                    if (config.namingConvention?.enumValues)
+                        value = convertNameParts(defaultValue.value, resolveExternalModuleAndFn(config.namingConvention?.enumValues), config.namingConvention?.transformUnderscore);
+                    appliedDirectivesGen = `${appliedDirectivesGen}.default(${type.name.value}.${value})`;
+                }
+                else {
+                    appliedDirectivesGen = `${appliedDirectivesGen}.default("${escapeGraphQLCharacters(defaultValue.value)}")`;
+                }
+            }
+        }
+        if (isNonNullType(parentType)) {
+            if (visitor.shouldEmitAsNotAllowEmptyString(type.name.value))
+                return `${appliedDirectivesGen}.min(1)`;
+            return appliedDirectivesGen;
+        }
+        if (isListType(parentType))
+            return `${appliedDirectivesGen}.nullable()`;
+        return `${appliedDirectivesGen}.nullish()`;
+    }
+    console.warn('unhandled type:', type);
+    return '';
+}
+function applyDirectives(config, field, gen) {
+    if (config.directives && field.directives) {
+        const formatted = formatDirectiveConfig(config.directives);
+        return gen + buildApi(formatted, field.directives);
+    }
+    return gen;
+}
+function generateNameNodeZodSchema(config, visitor, node) {
+    const converter = visitor.getNameNodeConverter(node);
+    switch (converter?.targetKind) {
+        case 'InterfaceTypeDefinition':
+        case 'InputObjectTypeDefinition':
+        case 'ObjectTypeDefinition':
+        case 'UnionTypeDefinition':
+            // using switch-case rather than if-else to allow for future expansion
+            switch (config.validationSchemaExportType) {
+                case 'const':
+                    return `${converter.convertName()}Schema`;
+                case 'function':
+                default:
+                    return `${converter.convertName()}Schema()`;
+            }
+        case 'EnumTypeDefinition':
+            return `${converter.convertName()}Schema`;
+        case 'ScalarTypeDefinition':
+            return zod4Scalar(config, visitor, node.value);
+        default:
+            if (converter?.targetKind)
+                console.warn('Unknown targetKind', converter?.targetKind);
+            return zod4Scalar(config, visitor, node.value);
+    }
+}
+function maybeLazy(visitor, type, schema) {
+    if (!isNamedType(type)) {
+        return schema;
+    }
+    const schemaType = visitor.getType(type.name.value);
+    const isComplexType = !isScalarType(schemaType) && !isEnumType(schemaType);
+    return isComplexType ? `z.lazy(() => ${schema})` : schema;
+}
+function zod4Scalar(config, visitor, scalarName) {
+    if (config.scalarSchemas?.[scalarName])
+        return config.scalarSchemas[scalarName];
+    const tsType = visitor.getScalarType(scalarName);
+    switch (tsType) {
+        case 'string':
+            return `z.string()`;
+        case 'number':
+            return `z.number()`;
+        case 'boolean':
+            return `z.boolean()`;
+    }
+    if (config.defaultScalarTypeSchema) {
+        return config.defaultScalarTypeSchema;
+    }
+    console.warn('unhandled scalar name:', scalarName);
+    return anySchema;
+}