@davars/graphql-codegen-zod 0.1.0

package/dist/directive.js

@@ -0,0 +1,211 @@
+import { Kind, valueFromASTUntyped } from 'graphql';
+import { isConvertableRegexp } from './regexp.js';
+function isFormattedDirectiveObjectArguments(arg) {
+    return arg !== undefined && !Array.isArray(arg);
+}
+// ```yml
+// directives:
+//   required:
+//     msg: required
+//   constraint:
+//     minLength: min
+//     format:
+//       uri: url
+//       email: email
+// ```
+//
+// This function convterts to like below
+// {
+//   'required': {
+//     'msg': ['required', '$1'],
+//   },
+//   'constraint': {
+//     'minLength': ['min', '$1'],
+//     'format': {
+//       'uri': ['url', '$2'],
+//       'email': ['email', '$2'],
+//     }
+//   }
+// }
+export function formatDirectiveConfig(config) {
+    return Object.fromEntries(Object.entries(config).map(([directive, arg]) => {
+        const formatted = Object.fromEntries(Object.entries(arg).map(([arg, val]) => {
+            if (Array.isArray(val))
+                return [arg, val];
+            if (typeof val === 'string')
+                return [arg, [val, '$1']];
+            return [arg, formatDirectiveObjectArguments(val)];
+        }));
+        return [directive, formatted];
+    }));
+}
+// ```yml
+// format:
+//   # For example, `@constraint(format: "uri")`. this case $1 will be "uri".
+//   # Therefore the generator generates yup schema `.url()` followed by `uri: 'url'`
+//   # If $1 does not match anywhere, the generator will ignore.
+//   uri: url
+//   email: ["email", "$2"]
+// ```
+//
+// This function convterts to like below
+// {
+//   'uri': ['url', '$2'],
+//   'email': ['email'],
+// }
+export function formatDirectiveObjectArguments(args) {
+    const formatted = Object.entries(args).map(([arg, val]) => {
+        if (Array.isArray(val))
+            return [arg, val];
+        return [arg, [val, '$2']];
+    });
+    return Object.fromEntries(formatted);
+}
+// This function generates `.required("message").min(100).email()`
+//
+// config
+// {
+//   'required': {
+//     'msg': ['required', '$1'],
+//   },
+//   'constraint': {
+//     'minLength': ['min', '$1'],
+//     'format': {
+//       'uri': ['url', '$2'],
+//       'email': ['email', '$2'],
+//     }
+//   }
+// }
+//
+// GraphQL schema
+// ```graphql
+// input ExampleInput {
+//   email: String! @required(msg: "message") @constraint(minLength: 100, format: "email")
+// }
+// ```
+export function buildApi(config, directives) {
+    return directives
+        .filter(directive => config[directive.name.value] !== undefined)
+        .map((directive) => {
+        const directiveName = directive.name.value;
+        const argsConfig = config[directiveName];
+        return buildApiFromDirectiveArguments(argsConfig, directive.arguments ?? []);
+    })
+        .join('');
+}
+// This function generates `[v.minLength(100), v.email()]`
+// NOTE: valibot's API is not a method chain, so it is prepared separately from buildApi.
+//
+// config
+// {
+//   'constraint': {
+//     'minLength': ['minLength', '$1'],
+//     'format': {
+//       'uri': ['url', '$2'],
+//       'email': ['email', '$2'],
+//     }
+//   }
+// }
+//
+// GraphQL schema
+// ```graphql
+// input ExampleInput {
+//   email: String! @required(msg: "message") @constraint(minLength: 100, format: "email")
+// }
+// ```
+//
+// FIXME: v.required() is not supported yet. v.required() is classified as `Methods` and must wrap the schema. ex) `v.required(v.object({...}))`
+export function buildApiForValibot(config, directives) {
+    return directives
+        .filter(directive => config[directive.name.value] !== undefined)
+        .map((directive) => {
+        const directiveName = directive.name.value;
+        const argsConfig = config[directiveName];
+        const apis = _buildApiFromDirectiveArguments(argsConfig, directive.arguments ?? []);
+        return apis.map(api => `v${api}`);
+    })
+        .flat();
+}
+function buildApiSchema(validationSchema, argValue) {
+    if (!validationSchema)
+        return '';
+    const schemaApi = validationSchema[0];
+    const schemaApiArgs = validationSchema.slice(1).map((templateArg) => {
+        const gqlSchemaArgs = apiArgsFromConstValueNode(argValue);
+        return applyArgToApiSchemaTemplate(templateArg, gqlSchemaArgs);
+    });
+    return `.${schemaApi}(${schemaApiArgs.join(', ')})`;
+}
+function buildApiFromDirectiveArguments(config, args) {
+    return _buildApiFromDirectiveArguments(config, args).join('');
+}
+function _buildApiFromDirectiveArguments(config, args) {
+    return args
+        .map((arg) => {
+        const argName = arg.name.value;
+        const validationSchema = config[argName];
+        if (isFormattedDirectiveObjectArguments(validationSchema))
+            return buildApiFromDirectiveObjectArguments(validationSchema, arg.value);
+        return buildApiSchema(validationSchema, arg.value);
+    });
+}
+function buildApiFromDirectiveObjectArguments(config, argValue) {
+    if (argValue.kind !== Kind.STRING && argValue.kind !== Kind.ENUM)
+        return '';
+    const validationSchema = config[argValue.value];
+    return buildApiSchema(validationSchema, argValue);
+}
+function applyArgToApiSchemaTemplate(template, apiArgs) {
+    const matches = template.matchAll(/\$(\d+)/g);
+    for (const match of matches) {
+        const placeholder = match[0]; // `$1`
+        const idx = Number.parseInt(match[1], 10) - 1; // start with `1 - 1`
+        const apiArg = apiArgs[idx];
+        if (apiArg === undefined) {
+            template = template.replace(placeholder, '');
+            continue;
+        }
+        if (template === placeholder)
+            return stringify(apiArg);
+        template = template.replace(placeholder, apiArg);
+    }
+    if (template !== '')
+        return stringify(template, true);
+    return template;
+}
+function stringify(arg, quoteString) {
+    if (Array.isArray(arg))
+        return arg.map(v => stringify(v, true)).join(',');
+    if (typeof arg === 'string') {
+        if (isConvertableRegexp(arg))
+            return arg;
+        const v = tryEval(arg);
+        if (v !== undefined)
+            arg = v;
+        if (quoteString)
+            return JSON.stringify(arg);
+    }
+    if (typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'bigint' || arg === 'undefined' || arg === null)
+        return `${arg}`;
+    return JSON.stringify(arg);
+}
+function apiArgsFromConstValueNode(value) {
+    const val = valueFromASTUntyped(value);
+    if (Array.isArray(val))
+        return val;
+    return [val];
+}
+function tryEval(maybeValidJavaScript) {
+    try {
+        // eslint-disable-next-line no-eval
+        return eval(maybeValidJavaScript);
+    }
+    catch {
+        return undefined;
+    }
+}
+export const exportedForTesting = {
+    applyArgToApiSchemaTemplate,
+    buildApiFromDirectiveObjectArguments,
+    buildApiFromDirectiveArguments,
+};

package/dist/graphql.d.ts

@@ -0,0 +1,21 @@
+import type { DocumentNode, GraphQLSchema, InterfaceTypeDefinitionNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, TypeNode } from 'graphql';
+import { Graph } from 'graphlib';
+export declare const isListType: (typ?: TypeNode) => typ is ListTypeNode;
+export declare const isNonNullType: (typ?: TypeNode) => typ is NonNullTypeNode;
+export declare const isNamedType: (typ?: TypeNode) => typ is NamedTypeNode;
+export declare const isInput: (kind: string) => boolean;
+type ObjectTypeDefinitionFn = (node: ObjectTypeDefinitionNode) => any;
+type InterfaceTypeDefinitionFn = (node: InterfaceTypeDefinitionNode) => any;
+export declare function ObjectTypeDefinitionBuilder(useObjectTypes: boolean | undefined, callback: ObjectTypeDefinitionFn): ObjectTypeDefinitionFn | undefined;
+export declare function InterfaceTypeDefinitionBuilder(useInterfaceTypes: boolean | undefined, callback: InterfaceTypeDefinitionFn): InterfaceTypeDefinitionFn | undefined;
+export declare function topologicalSortAST(schema: GraphQLSchema, ast: DocumentNode): DocumentNode;
+/**
+ * [Re-implemented topsort function][topsort-ref] with cycle handling. This version iterates over
+ * all nodes in the graph to ensure every node is visited, even if the graph contains cycles.
+ *
+ * [topsort-ref]: https://github.com/dagrejs/graphlib/blob/8d27cb89029081c72eb89dde652602805bdd0a34/lib/alg/topsort.js
+ */
+export declare function topsort(g: Graph): string[];
+export declare function isGeneratedByIntrospection(schema: GraphQLSchema): boolean;
+export declare function escapeGraphQLCharacters(input: string): string;
+export {};

package/dist/graphql.js

@@ -0,0 +1,167 @@
+import { Graph } from 'graphlib';
+import { isSpecifiedScalarType, Kind, visit, } from 'graphql';
+/**
+ * Recursively unwraps a GraphQL type until it reaches the NamedType.
+ *
+ * Since a GraphQL type is defined as either a NamedTypeNode, ListTypeNode, or NonNullTypeNode,
+ * this implementation safely recurses until the underlying NamedTypeNode is reached.
+ */
+function getNamedType(typeNode) {
+    return typeNode.kind === Kind.NAMED_TYPE ? typeNode : getNamedType(typeNode.type);
+}
+export const isListType = (typ) => typ?.kind === Kind.LIST_TYPE;
+export const isNonNullType = (typ) => typ?.kind === Kind.NON_NULL_TYPE;
+export const isNamedType = (typ) => typ?.kind === Kind.NAMED_TYPE;
+export const isInput = (kind) => kind.includes('Input');
+export function ObjectTypeDefinitionBuilder(useObjectTypes, callback) {
+    if (!useObjectTypes)
+        return undefined;
+    return (node) => {
+        if (/^(Query|Mutation|Subscription)$/.test(node.name.value))
+            return;
+        return callback(node);
+    };
+}
+export function InterfaceTypeDefinitionBuilder(useInterfaceTypes, callback) {
+    if (!useInterfaceTypes)
+        return undefined;
+    return (node) => {
+        return callback(node);
+    };
+}
+export function topologicalSortAST(schema, ast) {
+    const dependencyGraph = new Graph();
+    const targetKinds = [
+        Kind.OBJECT_TYPE_DEFINITION,
+        Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        Kind.INTERFACE_TYPE_DEFINITION,
+        Kind.SCALAR_TYPE_DEFINITION,
+        Kind.ENUM_TYPE_DEFINITION,
+        Kind.UNION_TYPE_DEFINITION,
+    ];
+    visit(ast, {
+        enter: (node) => {
+            switch (node.kind) {
+                case Kind.OBJECT_TYPE_DEFINITION:
+                case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                case Kind.INTERFACE_TYPE_DEFINITION: {
+                    const typeName = node.name.value;
+                    dependencyGraph.setNode(typeName);
+                    if (node.fields) {
+                        node.fields.forEach((field) => {
+                            // Unwrap the type
+                            const namedTypeNode = getNamedType(field.type);
+                            const dependency = namedTypeNode.name.value;
+                            const namedType = schema.getType(dependency);
+                            if (namedType?.astNode?.kind === undefined
+                                || !targetKinds.includes(namedType.astNode.kind)) {
+                                return;
+                            }
+                            if (!dependencyGraph.hasNode(dependency)) {
+                                dependencyGraph.setNode(dependency);
+                            }
+                            dependencyGraph.setEdge(typeName, dependency);
+                        });
+                    }
+                    break;
+                }
+                case Kind.SCALAR_TYPE_DEFINITION:
+                case Kind.ENUM_TYPE_DEFINITION: {
+                    dependencyGraph.setNode(node.name.value);
+                    break;
+                }
+                case Kind.UNION_TYPE_DEFINITION: {
+                    const dependency = node.name.value;
+                    if (!dependencyGraph.hasNode(dependency))
+                        dependencyGraph.setNode(dependency);
+                    node.types?.forEach((type) => {
+                        const dependency = type.name.value;
+                        const typ = schema.getType(dependency);
+                        if (typ?.astNode?.kind === undefined || !targetKinds.includes(typ.astNode.kind))
+                            return;
+                        dependencyGraph.setEdge(node.name.value, dependency);
+                    });
+                    break;
+                }
+                default:
+                    break;
+            }
+        },
+    });
+    const sorted = topsort(dependencyGraph);
+    // Create a map of definitions for quick access, using the definition's name as the key.
+    const definitionsMap = new Map();
+    // SCHEMA_DEFINITION does not have a name.
+    // https://spec.graphql.org/October2021/#sec-Schema
+    const astDefinitions = ast.definitions.filter(def => def.kind !== Kind.SCHEMA_DEFINITION);
+    astDefinitions.forEach((definition) => {
+        if (hasNameField(definition) && definition.name)
+            definitionsMap.set(definition.name.value, definition);
+    });
+    // Two arrays to store sorted and unsorted definitions.
+    const sortedDefinitions = [];
+    const notSortedDefinitions = [];
+    // Iterate over sorted type names and retrieve their corresponding definitions.
+    sorted.forEach((sortedType) => {
+        const definition = definitionsMap.get(sortedType);
+        if (definition) {
+            sortedDefinitions.push(definition);
+            definitionsMap.delete(sortedType);
+        }
+    });
+    // Definitions that are left in the map were not included in sorted list
+    // Add them to notSortedDefinitions.
+    definitionsMap.forEach(definition => notSortedDefinitions.push(definition));
+    const newDefinitions = [...sortedDefinitions, ...notSortedDefinitions];
+    if (newDefinitions.length !== astDefinitions.length) {
+        throw new Error(`Unexpected definition length after sorting: want ${astDefinitions.length} but got ${newDefinitions.length}`);
+    }
+    return {
+        ...ast,
+        definitions: newDefinitions,
+    };
+}
+function hasNameField(node) {
+    return 'name' in node;
+}
+/**
+ * [Re-implemented topsort function][topsort-ref] with cycle handling. This version iterates over
+ * all nodes in the graph to ensure every node is visited, even if the graph contains cycles.
+ *
+ * [topsort-ref]: https://github.com/dagrejs/graphlib/blob/8d27cb89029081c72eb89dde652602805bdd0a34/lib/alg/topsort.js
+ */
+export function topsort(g) {
+    const visited = new Set();
+    const results = [];
+    function visit(node) {
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        // Recursively visit all predecessors of the node.
+        g.predecessors(node)?.forEach(visit);
+        results.push(node);
+    }
+    // Visit every node in the graph (instead of only sinks)
+    g.nodes().forEach(visit);
+    return results.reverse();
+}
+export function isGeneratedByIntrospection(schema) {
+    return Object.entries(schema.getTypeMap())
+        .filter(([name, type]) => !name.startsWith('__') && !isSpecifiedScalarType(type))
+        .every(([, type]) => type.astNode === undefined);
+}
+// https://spec.graphql.org/October2021/#EscapedCharacter
+const escapeMap = {
+    '\"': '\\\"',
+    '\\': '\\\\',
+    '\/': '\\/',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+};
+export function escapeGraphQLCharacters(input) {
+    // eslint-disable-next-line regexp/no-escape-backspace
+    return input.replace(/["\\/\f\n\r\t\b]/g, match => escapeMap[match]);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
+import type { ValidationSchemaPluginConfig } from './config.js';
+export declare const plugin: PluginFunction<ValidationSchemaPluginConfig, Types.ComplexPluginOutput>;
+export type { ValidationSchemaPluginConfig };

package/dist/index.js

@@ -0,0 +1,37 @@
+import { transformSchemaAST } from '@graphql-codegen/schema-ast';
+import { buildSchema, printSchema, visit } from 'graphql';
+import { isGeneratedByIntrospection, topologicalSortAST } from './graphql.js';
+import { loadTransforms } from './transforms.js';
+import { ZodSchemaVisitor } from './zod.js';
+export const plugin = (schema, _documents, config, info) => {
+    const { schema: _schema, ast } = _transformSchemaAST(schema, config);
+    let resolvedTransforms = {};
+    if (config.transforms) {
+        const outputFile = info?.outputFile ?? 'output.ts';
+        resolvedTransforms = loadTransforms(config.transforms, outputFile);
+    }
+    const visitor = new ZodSchemaVisitor(_schema, config, resolvedTransforms);
+    const result = visit(ast, visitor);
+    const generated = result.definitions.filter(def => typeof def === 'string');
+    return {
+        prepend: visitor.buildImports(),
+        content: [visitor.initialEmit(), ...generated].join('\n'),
+    };
+};
+function _transformSchemaAST(schema, config) {
+    const { schema: _schema, ast } = transformSchemaAST(schema, config);
+    // See: https://github.com/Code-Hex/graphql-codegen-typescript-validation-schema/issues/394
+    const __schema = isGeneratedByIntrospection(_schema) ? buildSchema(printSchema(_schema)) : _schema;
+    // This affects the performance of code generation, so it is
+    // enabled only when this option is selected.
+    if (config.validationSchemaExportType === 'const') {
+        return {
+            schema: __schema,
+            ast: topologicalSortAST(__schema, ast),
+        };
+    }
+    return {
+        schema: __schema,
+        ast,
+    };
+}

package/dist/regexp.d.ts

@@ -0,0 +1 @@
+export declare const isConvertableRegexp: (maybeRegexp: string) => boolean;

package/dist/regexp.js

@@ -0,0 +1,2 @@
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#advanced_searching_with_flags
+export const isConvertableRegexp = (maybeRegexp) => /^\/.*\/[dgimsuy]*$/.test(maybeRegexp);

package/dist/schema_visitor.d.ts

@@ -0,0 +1,17 @@
+import type { FieldDefinitionNode, GraphQLSchema, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode } from 'graphql';
+import type { ValidationSchemaPluginConfig } from './config.js';
+import type { SchemaVisitor } from './types.js';
+import { Visitor } from './visitor.js';
+export declare abstract class BaseSchemaVisitor implements SchemaVisitor {
+    protected schema: GraphQLSchema;
+    protected config: ValidationSchemaPluginConfig;
+    protected importTypes: string[];
+    protected enumDeclarations: string[];
+    constructor(schema: GraphQLSchema, config: ValidationSchemaPluginConfig);
+    abstract importValidationSchema(): string;
+    buildImports(): string[];
+    abstract initialEmit(): string;
+    createVisitor(scalarDirection: 'input' | 'output' | 'both'): Visitor;
+    protected abstract buildInputFields(fields: readonly (FieldDefinitionNode | InputValueDefinitionNode)[], visitor: Visitor, name: string): string;
+    protected buildTypeDefinitionArguments(node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode, visitor: Visitor): string | undefined;
+}

package/dist/schema_visitor.js

@@ -0,0 +1,33 @@
+import { Visitor } from './visitor.js';
+export class BaseSchemaVisitor {
+    schema;
+    config;
+    importTypes = [];
+    enumDeclarations = [];
+    constructor(schema, config) {
+        this.schema = schema;
+        this.config = config;
+    }
+    buildImports() {
+        if (this.config.importFrom && this.importTypes.length > 0) {
+            const namedImportPrefix = this.config.useTypeImports ? 'type ' : '';
+            const importCore = this.config.schemaNamespacedImportName
+                ? `* as ${this.config.schemaNamespacedImportName}`
+                : `${namedImportPrefix}{ ${this.importTypes.join(', ')} }`;
+            return [
+                this.importValidationSchema(),
+                `import ${importCore} from '${this.config.importFrom}'`,
+            ];
+        }
+        return [this.importValidationSchema()];
+    }
+    createVisitor(scalarDirection) {
+        return new Visitor(scalarDirection, this.schema, this.config);
+    }
+    buildTypeDefinitionArguments(node, visitor) {
+        return visitor.buildArgumentsSchemaBlock(node, (typeName, field) => {
+            this.importTypes.push(typeName);
+            return this.buildInputFields(field.arguments ?? [], visitor, typeName);
+        });
+    }
+}

package/dist/transform_config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A transform function that converts a plain parsed object into a custom type.
+ * Used with Zod's `.transform()` to produce class instances from generated schemas.
+ */
+export type TransformFn = (raw: any) => unknown;
+/**
+ * Maps GraphQL type names to their transform functions.
+ *
+ * @example
+ * ```typescript
+ * import type { TransformConfig } from '@heath/codegen-plugin/transform_config'
+ * import { transformDateRange } from './models/DateRange'
+ *
+ * const config: TransformConfig = {
+ *   DateRange: transformDateRange,
+ * }
+ * export default config
+ * ```
+ */
+export type TransformConfig = Record<string, TransformFn>;

package/dist/transform_config.js

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

package/dist/transforms.d.ts

@@ -0,0 +1,35 @@
+import ts from 'typescript';
+export interface ResolvedTransform {
+    /** The function name to import in generated code */
+    symbolName: string;
+    /** The module path to import from (relative to output file) */
+    importPath: string;
+}
+/**
+ * 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 declare function loadTransforms(configPath: string, outputPath: string): Record<string, ResolvedTransform>;
+/**
+ * Extracts a map of imported symbol names to their module paths.
+ * Skips `import type` declarations since we need value imports.
+ */
+export declare function extractImportMap(sourceFile: ts.SourceFile): Map<string, string>;
+/**
+ * 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 declare function extractDefaultExportMap(sourceFile: ts.SourceFile): Map<string, string>;
+/**
+ * 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 declare function rebasePath(importPath: string, configPath: string, outputPath: string): string;