feat: support non-null and defined

Author: MH4GF

src/config.ts

@@ -1,6 +1,6 @@
 import type { TypeScriptPluginConfig } from '@graphql-codegen/typescript';
 
-export type ValidationSchema = 'yup' | 'zod' | 'myzod';
+export type ValidationSchema = 'yup' | 'zod' | 'myzod' | 'valibot';
 export type ValidationSchemaExportType = 'function' | 'const';
 
 export interface DirectiveConfig {

src/index.ts

@@ -9,6 +9,7 @@ import { MyZodSchemaVisitor } from './myzod/index';
 import type { SchemaVisitor } from './types';
 import { YupSchemaVisitor } from './yup/index';
 import { ZodSchemaVisitor } from './zod/index';
+import { ValibotSchemaVisitor } from './valibot';
 
 export const plugin: PluginFunction<ValidationSchemaPluginConfig, Types.ComplexPluginOutput> = (
   schema: GraphQLSchema,
@@ -33,6 +34,8 @@ function schemaVisitor(schema: GraphQLSchema, config: ValidationSchemaPluginConf
     return new ZodSchemaVisitor(schema, config);
   else if (config?.schema === 'myzod')
     return new MyZodSchemaVisitor(schema, config);
+  else if (config?.schema === 'valibot')
+    return new ValibotSchemaVisitor(schema, config);
 
   return new YupSchemaVisitor(schema, config);
 }

src/valibot/index.ts

@@ -0,0 +1,109 @@
+import { DeclarationBlock, indent } from '@graphql-codegen/visitor-plugin-common';
+import type {
+  FieldDefinitionNode,
+  GraphQLSchema,
+  InputObjectTypeDefinitionNode,
+  InputValueDefinitionNode,
+  NameNode,
+  TypeNode,
+} from 'graphql';
+
+import type { ValidationSchemaPluginConfig } from '../config';
+import { BaseSchemaVisitor } from '../schema_visitor';
+import type { Visitor } from '../visitor';
+import {
+  isNamedType,
+  isNonNullType,
+} from './../graphql';
+
+export class ValibotSchemaVisitor extends BaseSchemaVisitor {
+  constructor(schema: GraphQLSchema, config: ValidationSchemaPluginConfig) {
+    super(schema, config);
+  }
+
+  importValidationSchema(): string {
+    return `import * as v from 'valibot'`;
+  }
+
+  initialEmit(): string {
+    return '';
+  }
+
+  get InputObjectTypeDefinition() {
+    return {
+      leave: (node: InputObjectTypeDefinitionNode) => {
+        const visitor = this.createVisitor('input');
+        const name = visitor.convertName(node.name.value);
+        this.importTypes.push(name);
+        return this.buildInputFields(node.fields ?? [], visitor, name);
+      },
+    };
+  }
+
+  protected buildInputFields(
+    fields: readonly (FieldDefinitionNode | InputValueDefinitionNode)[],
+    visitor: Visitor,
+    name: string,
+  ) {
+    const shape = fields.map(field => generateFieldValibotSchema(this.config, visitor, field, 2)).join(',\n');
+
+    switch (this.config.validationSchemaExportType) {
+      default:
+        return new DeclarationBlock({})
+          .export()
+          .asKind('function')
+          .withName(`${name}Schema(): v.GenericSchema<${name}>`)
+          .withBlock([indent(`return v.object({`), shape, indent('})')].join('\n')).string;
+    }
+  }
+}
+
+function generateFieldValibotSchema(config: ValidationSchemaPluginConfig, visitor: Visitor, field: InputValueDefinitionNode | FieldDefinitionNode, indentCount: number): string {
+  const gen = generateFieldTypeValibotSchema(config, visitor, field, field.type);
+  return indent(`${field.name.value}: ${maybeLazy(field.type, gen)}`, indentCount);
+}
+
+function generateFieldTypeValibotSchema(config: ValidationSchemaPluginConfig, visitor: Visitor, field: InputValueDefinitionNode | FieldDefinitionNode, type: TypeNode, parentType?: TypeNode): string {
+  if (isNonNullType(type)) {
+    const gen = generateFieldTypeValibotSchema(config, visitor, field, type.type, type);
+    return maybeLazy(type.type, gen);
+  }
+  if (isNamedType(type)) {
+    const gen = generateNameNodeValibotSchema(config, visitor, type.name);
+
+    if (isNonNullType(parentType))
+      return gen;
+  }
+  console.warn('unhandled type:', type);
+  return '';
+}
+
+function generateNameNodeValibotSchema(config: ValidationSchemaPluginConfig, visitor: Visitor, node: NameNode): string {
+  const converter = visitor.getNameNodeConverter(node);
+
+  switch (converter?.targetKind) {
+    default:
+      if (converter?.targetKind)
+        console.warn('Unknown targetKind', converter?.targetKind);
+
+      return valibot4Scalar(config, visitor, node.value);
+  }
+}
+
+function maybeLazy(type: TypeNode, schema: string): string {
+  return schema;
+}
+
+function valibot4Scalar(config: ValidationSchemaPluginConfig, visitor: Visitor, scalarName: string): string {
+  const tsType = visitor.getScalarType(scalarName);
+  switch (tsType) {
+    case 'string':
+      return `v.string()`;
+    case 'number':
+      return `v.number()`;
+    case 'boolean':
+      return `v.boolean()`;
+  }
+  console.warn('unhandled scalar name:', scalarName);
+  return 'v.any()';
+}

tests/valibot.spec.ts

@@ -0,0 +1,34 @@
+import { buildSchema } from 'graphql';
+
+import { plugin } from '../src/index';
+
+describe('valibot', () => {
+  it('non-null and defined', async () => {
+    const schema = buildSchema(/* GraphQL */ `
+      input PrimitiveInput {
+        a: ID!
+        b: String!
+        c: Boolean!
+        d: Int!
+        e: Float!
+      }
+    `);
+    const scalars = {
+      ID: 'string',
+    }
+    const result = await plugin(schema, [], { schema: 'valibot', scalars }, {});
+    expect(result.content).toMatchInlineSnapshot(`
+      "
+      export function PrimitiveInputSchema(): v.GenericSchema<PrimitiveInput> {
+        return v.object({
+          a: v.string(),
+          b: v.string(),
+          c: v.boolean(),
+          d: v.number(),
+          e: v.number()
+        })
+      }
+      "
+    `);
+  })
+})