feat: implement 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/index';
 
 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,121 @@
+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';
+
+const anySchema = `definedNonNullAnySchema`;
+
+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) {
+      case 'const':
+        throw new Error('not implemented');
+      case 'function':
+      default:
+        return new DeclarationBlock({})
+          .export()
+          .asKind('function')
+          .withName(`${name}Schema()`)
+          .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) {
+    case 'InterfaceTypeDefinition':
+    case 'InputObjectTypeDefinition':
+    case 'ObjectTypeDefinition':
+    case 'UnionTypeDefinition':
+    case 'EnumTypeDefinition':
+    case 'ScalarTypeDefinition':
+      throw new Error('not implemented');
+    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 anySchema;
+}

tests/valibot.spec.ts

@@ -0,0 +1,40 @@
+import { buildSchema } from 'graphql';
+
+import { plugin } from '../src/index';
+
+describe('valibot', () => {
+  it.each([
+    [
+      'non-null and defined',
+      {
+        textSchema: /* GraphQL */ `
+          input PrimitiveInput {
+            a: ID!
+            b: String!
+            c: Boolean!
+            d: Int!
+            e: Float!
+          }
+        `,
+        wantContains: [
+          'export function PrimitiveInputSchema()',
+          'a: v.string(),',
+          'b: v.string(),',
+          'c: v.boolean(),',
+          'd: v.number(),',
+          'e: v.number()',
+        ],
+        scalars: {
+          ID: 'string',
+        },
+      },
+    ],
+  ])('%s', async (_, { textSchema, wantContains, scalars }) => {
+    const schema = buildSchema(textSchema);
+    const result = await plugin(schema, [], { schema: 'valibot', scalars }, {});
+    expect(result.prepend).toContain('import * as v from \'valibot\'');
+
+    for (const wantContain of wantContains)
+      expect(result.content).toContain(wantContain);
+  });
+})