Code-Hex · Code-Hex · Apr 15, 2023 · Apr 15, 2023
diff --git a/.eslintrc.json b/.eslintrc.json
@@ -28,7 +28,8 @@
       "rules": {
         "no-unused-vars": "off",
         "@typescript-eslint/no-unused-vars": "off",
-        "import/no-extraneous-dependencies": "off"
+        "import/no-extraneous-dependencies": "off",
+        "prefer-object-has-own": "off"
       }
     }
   ],

diff --git a/package.json b/package.json
@@ -64,11 +64,11 @@
     "zod": "3.21.4"
   },
   "dependencies": {
-    "@graphql-codegen/plugin-helpers": "2.7.2",
+    "@graphql-codegen/plugin-helpers": "^4.2.0",
     "@graphql-codegen/schema-ast": "2.6.1",
     "@graphql-codegen/visitor-plugin-common": "^2.13.7",
     "@graphql-tools/utils": "^9.0.0",
-    "graphql": "16.6.0"
+    "graphql": "^16.6.0"
   },
   "peerDependencies": {
     "graphql": "^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"

diff --git a/src/index.ts b/src/index.ts
@@ -3,8 +3,9 @@ import { MyZodSchemaVisitor } from './myzod/index';
 import { transformSchemaAST } from '@graphql-codegen/schema-ast';
 import { YupSchemaVisitor } from './yup/index';
 import { ValidationSchemaPluginConfig } from './config';
-import { oldVisit, PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
-import { GraphQLSchema } from 'graphql';
+import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
+import { GraphQLSchema, visit } from 'graphql';
+import { SchemaVisitor } from './types';
 
 export const plugin: PluginFunction<ValidationSchemaPluginConfig, Types.ComplexPluginOutput> = (
   schema: GraphQLSchema,
@@ -14,9 +15,7 @@ export const plugin: PluginFunction<ValidationSchemaPluginConfig, Types.ComplexP
   const { schema: _schema, ast } = transformSchemaAST(schema, config);
   const { buildImports, initialEmit, ...visitor } = schemaVisitor(_schema, config);
 
-  const result = oldVisit(ast, {
-    leave: visitor,
-  });
+  const result = visit(ast, visitor);
 
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
@@ -28,7 +27,7 @@ export const plugin: PluginFunction<ValidationSchemaPluginConfig, Types.ComplexP
   };
 };
 
-const schemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig) => {
+const schemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig): SchemaVisitor => {
   if (config?.schema === 'zod') {
     return ZodSchemaVisitor(schema, config);
   } else if (config?.schema === 'myzod') {

diff --git a/src/myzod/index.ts b/src/myzod/index.ts
@@ -14,11 +14,12 @@ import {
 import { DeclarationBlock, indent } from '@graphql-codegen/visitor-plugin-common';
 import { TsVisitor } from '@graphql-codegen/typescript';
 import { buildApi, formatDirectiveConfig } from '../directive';
+import { SchemaVisitor } from '../types';
 
 const importZod = `import * as myzod from 'myzod'`;
 const anySchema = `definedNonNullAnySchema`;
 
-export const MyZodSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig) => {
+export const MyZodSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig): SchemaVisitor => {
   const tsVisitor = new TsVisitor(schema, config);
 
   const importTypes: string[] = [];
@@ -36,72 +37,80 @@ export const MyZodSchemaVisitor = (schema: GraphQLSchema, config: ValidationSche
         new DeclarationBlock({}).export().asKind('const').withName(`${anySchema}`).withContent(`myzod.object({})`)
           .string,
       ].join('\n'),
-    InputObjectTypeDefinition: (node: InputObjectTypeDefinitionNode) => {
-      const name = tsVisitor.convertName(node.name.value);
-      importTypes.push(name);
-
-      const shape = node.fields
-        ?.map(field => generateFieldMyZodSchema(config, tsVisitor, schema, field, 2))
-        .join(',\n');
-
-      return new DeclarationBlock({})
-        .export()
-        .asKind('function')
-        .withName(`${name}Schema(): myzod.Type<${name}>`)
-        .withBlock([indent(`return myzod.object({`), shape, indent('})')].join('\n')).string;
+    InputObjectTypeDefinition: {
+      leave: (node: InputObjectTypeDefinitionNode) => {
+        const name = tsVisitor.convertName(node.name.value);
+        importTypes.push(name);
+
+        const shape = node.fields
+          ?.map(field => generateFieldMyZodSchema(config, tsVisitor, schema, field, 2))
+          .join(',\n');
+
+        return new DeclarationBlock({})
+          .export()
+          .asKind('function')
+          .withName(`${name}Schema(): myzod.Type<${name}>`)
+          .withBlock([indent(`return myzod.object({`), shape, indent('})')].join('\n')).string;
+      },
     },
-    ObjectTypeDefinition: ObjectTypeDefinitionBuilder(config.withObjectType, (node: ObjectTypeDefinitionNode) => {
-      const name = tsVisitor.convertName(node.name.value);
-      importTypes.push(name);
-
-      const shape = node.fields
-        ?.map(field => generateFieldMyZodSchema(config, tsVisitor, schema, field, 2))
-        .join(',\n');
-
-      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;
-    }),
-    EnumTypeDefinition: (node: EnumTypeDefinitionNode) => {
-      const enumname = tsVisitor.convertName(node.name.value);
-      importTypes.push(enumname);
-      // z.enum are basically myzod.literals
-      if (config.enumsAsTypes) {
+    ObjectTypeDefinition: {
+      leave: ObjectTypeDefinitionBuilder(config.withObjectType, (node: ObjectTypeDefinitionNode) => {
+        const name = tsVisitor.convertName(node.name.value);
+        importTypes.push(name);
+
+        const shape = node.fields
+          ?.map(field => generateFieldMyZodSchema(config, tsVisitor, schema, field, 2))
+          .join(',\n');
+
         return new DeclarationBlock({})
           .export()
-          .asKind('type')
-          .withName(`${enumname}Schema`)
-          .withContent(`myzod.literals(${node.values?.map(enumOption => `'${enumOption.name.value}'`).join(', ')})`)
-          .string;
-      }
+          .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;
+      }),
+    },
+    EnumTypeDefinition: {
+      leave: (node: EnumTypeDefinitionNode) => {
+        const enumname = tsVisitor.convertName(node.name.value);
+        importTypes.push(enumname);
+        // z.enum are basically myzod.literals
+        if (config.enumsAsTypes) {
+          return new DeclarationBlock({})
+            .export()
+            .asKind('type')
+            .withName(`${enumname}Schema`)
+            .withContent(`myzod.literals(${node.values?.map(enumOption => `'${enumOption.name.value}'`).join(', ')})`)
+            .string;
+        }
 
-      return new DeclarationBlock({})
-        .export()
-        .asKind('const')
-        .withName(`${enumname}Schema`)
-        .withContent(`myzod.enum(${enumname})`).string;
+        return new DeclarationBlock({})
+          .export()
+          .asKind('const')
+          .withName(`${enumname}Schema`)
+          .withContent(`myzod.enum(${enumname})`).string;
+      },
     },
-    UnionTypeDefinition: (node: UnionTypeDefinitionNode) => {
-      if (!node.types || !config.withObjectType) return;
+    UnionTypeDefinition: {
+      leave: (node: UnionTypeDefinitionNode) => {
+        if (!node.types || !config.withObjectType) return;
 
-      const unionName = tsVisitor.convertName(node.name.value);
-      const unionElements = node.types?.map(t => `${tsVisitor.convertName(t.name.value)}Schema()`).join(', ');
-      const unionElementsCount = node.types?.length ?? 0;
+        const unionName = tsVisitor.convertName(node.name.value);
+        const unionElements = node.types?.map(t => `${tsVisitor.convertName(t.name.value)}Schema()`).join(', ');
+        const unionElementsCount = node.types?.length ?? 0;
 
-      const union =
-        unionElementsCount > 1 ? indent(`return myzod.union([${unionElements}])`) : indent(`return ${unionElements}`);
+        const union =
+          unionElementsCount > 1 ? indent(`return myzod.union([${unionElements}])`) : indent(`return ${unionElements}`);
 
-      return new DeclarationBlock({}).export().asKind('function').withName(`${unionName}Schema()`).withBlock(union)
-        .string;
+        return new DeclarationBlock({}).export().asKind('function').withName(`${unionName}Schema()`).withBlock(union)
+          .string;
+      },
     },
   };
 };

diff --git a/src/types.ts b/src/types.ts
@@ -0,0 +1,13 @@
+import { oldVisit } from '@graphql-codegen/plugin-helpers';
+import { ASTNode, ASTVisitFn } from 'graphql';
+
+export type NewVisitor = Partial<{
+  readonly [NodeT in ASTNode as NodeT['kind']]?: {
+    leave?: ASTVisitFn<NodeT>;
+  };
+}>;
+export type OldLeaveVisitor = Partial<Parameters<typeof oldVisit>[1]['leave']>;
+export type SchemaVisitor = {
+  buildImports: () => string[];
+  initialEmit: () => string;
+} & NewVisitor;
diff --git a/src/yup/index.ts b/src/yup/index.ts
@@ -14,10 +14,11 @@ import {
 import { DeclarationBlock, indent } from '@graphql-codegen/visitor-plugin-common';
 import { TsVisitor } from '@graphql-codegen/typescript';
 import { buildApi, formatDirectiveConfig } from '../directive';
+import { SchemaVisitor } from '../types';
 
 const importYup = `import * as yup from 'yup'`;
 
-export const YupSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig) => {
+export const YupSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig): SchemaVisitor => {
   const tsVisitor = new TsVisitor(schema, config);
 
   const importTypes: string[] = [];
@@ -45,80 +46,92 @@ export const YupSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchema
           ).string
       );
     },
-    InputObjectTypeDefinition: (node: InputObjectTypeDefinitionNode) => {
-      const name = tsVisitor.convertName(node.name.value);
-      importTypes.push(name);
+    InputObjectTypeDefinition: {
+      leave: (node: InputObjectTypeDefinitionNode) => {
+        const name = tsVisitor.convertName(node.name.value);
+        importTypes.push(name);
 
-      const shape = node.fields?.map(field => generateFieldYupSchema(config, tsVisitor, schema, field, 2)).join(',\n');
+        const shape = node.fields
+          ?.map(field => generateFieldYupSchema(config, tsVisitor, schema, field, 2))
+          .join(',\n');
 
-      return new DeclarationBlock({})
-        .export()
-        .asKind('function')
-        .withName(`${name}Schema(): yup.SchemaOf<${name}>`)
-        .withBlock([indent(`return yup.object({`), shape, indent('})')].join('\n')).string;
+        return new DeclarationBlock({})
+          .export()
+          .asKind('function')
+          .withName(`${name}Schema(): yup.SchemaOf<${name}>`)
+          .withBlock([indent(`return yup.object({`), shape, indent('})')].join('\n')).string;
+      },
     },
-    ObjectTypeDefinition: ObjectTypeDefinitionBuilder(config.withObjectType, (node: ObjectTypeDefinitionNode) => {
-      const name = tsVisitor.convertName(node.name.value);
-      importTypes.push(name);
+    ObjectTypeDefinition: {
+      leave: ObjectTypeDefinitionBuilder(config.withObjectType, (node: ObjectTypeDefinitionNode) => {
+        const name = tsVisitor.convertName(node.name.value);
+        importTypes.push(name);
 
-      const shape = node.fields?.map(field => generateFieldYupSchema(config, tsVisitor, schema, field, 2)).join(',\n');
+        const shape = node.fields
+          ?.map(field => generateFieldYupSchema(config, tsVisitor, schema, field, 2))
+          .join(',\n');
 
-      return new DeclarationBlock({})
-        .export()
-        .asKind('function')
-        .withName(`${name}Schema(): yup.SchemaOf<${name}>`)
-        .withBlock(
-          [
-            indent(`return yup.object({`),
-            indent(`__typename: yup.mixed().oneOf(['${node.name.value}', undefined]),`, 2),
-            shape,
-            indent('})'),
-          ].join('\n')
-        ).string;
-    }),
-    EnumTypeDefinition: (node: EnumTypeDefinitionNode) => {
-      const enumname = tsVisitor.convertName(node.name.value);
-      importTypes.push(enumname);
+        return new DeclarationBlock({})
+          .export()
+          .asKind('function')
+          .withName(`${name}Schema(): yup.SchemaOf<${name}>`)
+          .withBlock(
+            [
+              indent(`return yup.object({`),
+              indent(`__typename: yup.mixed().oneOf(['${node.name.value}', undefined]),`, 2),
+              shape,
+              indent('})'),
+            ].join('\n')
+          ).string;
+      }),
+    },
+    EnumTypeDefinition: {
+      leave: (node: EnumTypeDefinitionNode) => {
+        const enumname = tsVisitor.convertName(node.name.value);
+        importTypes.push(enumname);
+
+        if (config.enumsAsTypes) {
+          return new DeclarationBlock({})
+            .export()
+            .asKind('const')
+            .withName(`${enumname}Schema`)
+            .withContent(
+              `yup.mixed().oneOf([${node.values?.map(enumOption => `'${enumOption.name.value}'`).join(', ')}])`
+            ).string;
+        }
 
-      if (config.enumsAsTypes) {
+        const values = node.values
+          ?.map(
+            enumOption =>
+              `${enumname}.${tsVisitor.convertName(enumOption.name, {
+                useTypesPrefix: false,
+                transformUnderscore: true,
+              })}`
+          )
+          .join(', ');
         return new DeclarationBlock({})
           .export()
           .asKind('const')
           .withName(`${enumname}Schema`)
-          .withContent(
-            `yup.mixed().oneOf([${node.values?.map(enumOption => `'${enumOption.name.value}'`).join(', ')}])`
-          ).string;
-      }
-
-      const values = node.values
-        ?.map(
-          enumOption =>
-            `${enumname}.${tsVisitor.convertName(enumOption.name, {
-              useTypesPrefix: false,
-              transformUnderscore: true,
-            })}`
-        )
-        .join(', ');
-      return new DeclarationBlock({})
-        .export()
-        .asKind('const')
-        .withName(`${enumname}Schema`)
-        .withContent(`yup.mixed().oneOf([${values}])`).string;
+          .withContent(`yup.mixed().oneOf([${values}])`).string;
+      },
     },
-    UnionTypeDefinition: (node: UnionTypeDefinitionNode) => {
-      if (!node.types || !config.withObjectType) return;
+    UnionTypeDefinition: {
+      leave: (node: UnionTypeDefinitionNode) => {
+        if (!node.types || !config.withObjectType) return;
 
-      const unionName = tsVisitor.convertName(node.name.value);
-      importTypes.push(unionName);
+        const unionName = tsVisitor.convertName(node.name.value);
+        importTypes.push(unionName);
 
-      const unionElements = node.types?.map(t => `${tsVisitor.convertName(t.name.value)}Schema()`).join(', ');
-      const union = indent(`return union<${unionName}>(${unionElements})`);
+        const unionElements = node.types?.map(t => `${tsVisitor.convertName(t.name.value)}Schema()`).join(', ');
+        const union = indent(`return union<${unionName}>(${unionElements})`);
 
-      return new DeclarationBlock({})
-        .export()
-        .asKind('function')
-        .withName(`${unionName}Schema(): yup.BaseSchema<${unionName}>`)
-        .withBlock(union).string;
+        return new DeclarationBlock({})
+          .export()
+          .asKind('function')
+          .withName(`${unionName}Schema(): yup.BaseSchema<${unionName}>`)
+          .withBlock(union).string;
+      },
     },
     // ScalarTypeDefinition: (node) => {
     //   const decl = new DeclarationBlock({})