feat: support interface type

Author: MH4GF

src/valibot/index.ts

@@ -5,6 +5,7 @@ import type {
   GraphQLSchema,
   InputObjectTypeDefinitionNode,
   InputValueDefinitionNode,
+  InterfaceTypeDefinitionNode,
   NameNode,
   ObjectTypeDefinitionNode,
   TypeNode,
@@ -16,6 +17,7 @@ import { BaseSchemaVisitor } from '../schema_visitor';
 import type { Visitor } from '../visitor';
 import { buildApiForValibot, formatDirectiveConfig } from '../directive';
 import {
+  InterfaceTypeDefinitionBuilder,
   ObjectTypeDefinitionBuilder,
   isInput,
   isListType,
@@ -51,6 +53,34 @@ export class ValibotSchemaVisitor extends BaseSchemaVisitor {
     };
   }
 
+  get InterfaceTypeDefinition() {
+    return {
+      leave: InterfaceTypeDefinitionBuilder(this.config.withObjectType, (node: InterfaceTypeDefinitionNode) => {
+        const visitor = this.createVisitor('output');
+        const name = visitor.convertName(node.name.value);
+        this.importTypes.push(name);
+
+        // 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 => 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 + appendArguments
+            );
+        }
+      }),
+    };
+  }
+
   get ObjectTypeDefinition() {
     return {
       leave: ObjectTypeDefinitionBuilder(this.config.withObjectType, (node: ObjectTypeDefinitionNode) => {
@@ -220,6 +250,7 @@ function generateNameNodeValibotSchema(config: ValidationSchemaPluginConfig, vis
   const converter = visitor.getNameNodeConverter(node);
 
   switch (converter?.targetKind) {
+    case 'InterfaceTypeDefinition':
     case 'InputObjectTypeDefinition':
     case 'ObjectTypeDefinition':
     case 'UnionTypeDefinition':

tests/valibot.spec.ts

@@ -778,4 +778,161 @@ describe('valibot', () => {
       "
     `)
   });
+  describe('with InterfaceType', () => {
+    it('not generate if withObjectType false', async () => {
+      const schema = buildSchema(/* GraphQL */ `
+        interface User {
+          id: ID!
+          name: String
+        }
+      `);
+      const result = await plugin(
+        schema,
+        [],
+        {
+          schema: 'valibot',
+          withObjectType: false,
+        },
+        {},
+      );
+      expect(result.content).not.toContain('export function UserSchema(): v.GenericSchema<User>');
+    });
+    it('generate if withObjectType true', async () => {
+      const schema = buildSchema(/* GraphQL */ `
+        interface Book {
+          title: String
+        }
+      `);
+      const result = await plugin(
+        schema,
+        [],
+        {
+          schema: 'valibot',
+          withObjectType: true,
+        },
+        {},
+      );
+      expect(result.content).toMatchInlineSnapshot(`
+        "
+
+        export function BookSchema(): v.GenericSchema<Book> {
+          return v.object({
+            title: v.nullish(v.string())
+          })
+        }
+        "
+      `)
+    });
+    it('generate interface type contains interface type', async () => {
+      const schema = buildSchema(/* GraphQL */ `
+        interface Book {
+          author: Author
+          title: String
+        }
+
+        interface Author {
+          books: [Book]
+          name: String
+        }
+      `);
+      const result = await plugin(
+        schema,
+        [],
+        {
+          schema: 'valibot',
+          withObjectType: true,
+        },
+        {},
+      );
+      expect(result.content).toMatchInlineSnapshot(`
+        "
+
+        export function BookSchema(): v.GenericSchema<Book> {
+          return v.object({
+            author: v.nullish(AuthorSchema()),
+            title: v.nullish(v.string())
+          })
+        }
+
+        export function AuthorSchema(): v.GenericSchema<Author> {
+          return v.object({
+            books: v.nullish(v.array(v.nullable(BookSchema()))),
+            name: v.nullish(v.string())
+          })
+        }
+        "
+      `)
+    });
+    it('generate object type contains interface type', async () => {
+      const schema = buildSchema(/* GraphQL */ `
+        interface Book {
+          title: String!
+          author: Author!
+        }
+
+        type Textbook implements Book {
+          title: String!
+          author: Author!
+          courses: [String!]!
+        }
+
+        type ColoringBook implements Book {
+          title: String!
+          author: Author!
+          colors: [String!]!
+        }
+
+        type Author {
+          books: [Book!]
+          name: String
+        }
+      `);
+      const result = await plugin(
+        schema,
+        [],
+        {
+          schema: 'valibot',
+          withObjectType: true,
+        },
+        {},
+      );
+      expect(result.content).toMatchInlineSnapshot(`
+        "
+
+        export function BookSchema(): v.GenericSchema<Book> {
+          return v.object({
+            title: v.string(),
+            author: AuthorSchema()
+          })
+        }
+
+        export function TextbookSchema(): v.GenericSchema<Textbook> {
+          return v.object({
+            __typename: v.optional(v.literal('Textbook')),
+            title: v.string(),
+            author: AuthorSchema(),
+            courses: v.array(v.string())
+          })
+        }
+
+        export function ColoringBookSchema(): v.GenericSchema<ColoringBook> {
+          return v.object({
+            __typename: v.optional(v.literal('ColoringBook')),
+            title: v.string(),
+            author: AuthorSchema(),
+            colors: v.array(v.string())
+          })
+        }
+
+        export function AuthorSchema(): v.GenericSchema<Author> {
+          return v.object({
+            __typename: v.optional(v.literal('Author')),
+            books: v.nullish(v.array(BookSchema())),
+            name: v.nullish(v.string())
+          })
+        }
+        "
+      `)
+    });
+  })
 })