InterfaceTypeDefinition for myzod

Author: simonljus

src/myzod/index.ts

@@ -5,6 +5,7 @@ import type {
   GraphQLSchema,
   InputObjectTypeDefinitionNode,
   InputValueDefinitionNode,
+  InterfaceTypeDefinitionNode,
   NameNode,
   ObjectTypeDefinitionNode,
   TypeNode,
@@ -17,8 +18,15 @@ import {
 import type { ValidationSchemaPluginConfig } from '../config';
 import { buildApi, formatDirectiveConfig } from '../directive';
 import { BaseSchemaVisitor } from '../schema_visitor';
-import type { Visitor } from '../visitor';
-import { ObjectTypeDefinitionBuilder, isInput, isListType, isNamedType, isNonNullType } from './../graphql';
+import { Visitor } from '../visitor';
+import {
+  InterfaceTypeDefinitionBuilder,
+  isInput,
+  isListType,
+  isNamedType,
+  isNonNullType,
+  ObjectTypeDefinitionBuilder,
+} from './../graphql';
 
 const anySchema = `definedNonNullAnySchema`;
 
@@ -53,6 +61,51 @@ export class MyZodSchemaVisitor extends BaseSchemaVisitor {
     };
   }
 
+  get InterfaceTypeDefinition() {
+    return {
+      leave: InterfaceTypeDefinitionBuilder(this.config.withInterfaceType, (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 => generateFieldMyZodSchema(this.config, visitor, field, 2)).join(',\n');
+
+        switch (this.config.validationSchemaExportType) {
+          case 'const':
+            return (
+              new DeclarationBlock({})
+                .export()
+                .asKind('const')
+                .withName(`${name}Schema: myzod.Type<${name}>`)
+                .withContent([`myzod.object({`, shape, '})'].join('\n')).string + appendArguments
+            );
+
+          case 'function':
+          default:
+            return (
+              new DeclarationBlock({})
+                .export()
+                .asKind('function')
+                .withName(`${name}Schema(): myzod.Type<${name}>`)
+                .withBlock(
+                  [
+                    indent(`return myzod.object({`),
+                    indent(`__typename: myzod.literal('${node.name.value}').optional(),`, 2),
+                    shape,
+                    indent('})'),
+                  ].join('\n')
+                ).string + appendArguments
+            );
+        }
+      }),
+    };
+  }
+
   get ObjectTypeDefinition() {
     return {
       leave: ObjectTypeDefinitionBuilder(this.config.withObjectType, (node: ObjectTypeDefinitionNode) => {
@@ -266,6 +319,7 @@ function generateNameNodeMyZodSchema(config: ValidationSchemaPluginConfig, visit
   const converter = visitor.getNameNodeConverter(node);
 
   switch (converter?.targetKind) {
+    case 'InterfaceTypeDefinition':
     case 'InputObjectTypeDefinition':
     case 'ObjectTypeDefinition':
     case 'UnionTypeDefinition':
@@ -279,7 +333,12 @@ function generateNameNodeMyZodSchema(config: ValidationSchemaPluginConfig, visit
       }
     case 'EnumTypeDefinition':
       return `${converter.convertName()}Schema`;
+    case 'ScalarTypeDefinition':
+      return myzod4Scalar(config, visitor, node.value);
     default:
+      if (converter?.targetKind) {
+        console.warn('Unknown target kind', converter.targetKind);
+      }
       return myzod4Scalar(config, visitor, node.value);
   }
 }

tests/myzod.spec.ts

@@ -486,6 +486,61 @@ describe('myzod', () => {
     });
   });
 
+  describe('with withInterfaceType', () => {
+    it('not generate if withObjectType false', async () => {
+      const schema = buildSchema(/* GraphQL */ `
+        interface User {
+          id: ID!
+          name: String
+        }
+      `);
+      const result = await plugin(
+        schema,
+        [],
+        {
+          schema: 'myzod',
+        },
+        {}
+      );
+      expect(result.content).not.toContain('export function UserSchema(): myzod.Type<User> {');
+    });
+
+    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: 'myzod',
+          withInterfaceType: true,
+        },
+        {}
+      );
+      const wantContains = [
+        'export function AuthorSchema(): myzod.Type<Author> {',
+        'books: myzod.array(BookSchema().nullable()).optional().nullable(),',
+        'name: myzod.string().optional().nullable()',
+
+        'export function BookSchema(): myzod.Type<Book> {',
+        'author: AuthorSchema().optional().nullable(),',
+        'title: myzod.string().optional().nullable()',
+      ];
+      for (const wantContain of wantContains) {
+        expect(result.content).toContain(wantContain);
+      }
+    });
+  });
+
   describe('with withObjectType', () => {
     it('not generate if withObjectType false', async () => {
       const schema = buildSchema(/* GraphQL */ `