Implemented support for myzod

Author: Parables

src/myzod/index.ts

@@ -12,7 +12,7 @@ import { DeclarationBlock, indent } from '@graphql-codegen/visitor-plugin-common
 import { TsVisitor } from '@graphql-codegen/typescript';
 import { buildApi, formatDirectiveConfig } from '../directive';
 
-const importZod = `import { z } from 'zod'`;
+const importZod = `import myzod from 'myzod'`;
 const anySchema = `definedNonNullAnySchema`;
 
 export const ZodSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig) => {
@@ -27,13 +27,21 @@ export const ZodSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchema
       }
       return [importZod];
     },
+
     initialEmit: (): string =>
       '\n' +
       [
+        /*
+        * MyZod allows you to create typed objects with `myzod.Type<YourCustomType>`
+        * See https://www.npmjs.com/package/myzod#lazy
         new DeclarationBlock({})
           .asKind('type')
           .withName('Properties<T>')
           .withContent(['Required<{', '  [K in keyof T]: z.ZodType<T[K], any, T[K]>;', '}>'].join('\n')).string,
+       */
+        /* 
+        * MyZod allows empty object hence no need for these hacks
+        * See https://www.npmjs.com/package/myzod#object
         // Unfortunately, zod doesn’t provide non-null defined any schema.
         // This is a temporary hack until it is fixed.
         // see: https://github.com/colinhacks/zod/issues/884
@@ -48,54 +56,55 @@ export const ZodSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchema
           .asKind('const')
           .withName(`${anySchema}`)
           .withContent(`z.any().refine((v) => isDefinedNonNullAny(v))`).string,
+     */
       ].join('\n'),
     InputObjectTypeDefinition: (node: InputObjectTypeDefinitionNode) => {
       const name = tsVisitor.convertName(node.name.value);
       importTypes.push(name);
 
       const shape = node.fields
-        ?.map(field => generateInputObjectFieldZodSchema(config, tsVisitor, schema, field, 2))
+        ?.map(field => generateInputObjectFieldMyZodSchema(config, tsVisitor, schema, field, 2))
         .join(',\n');
 
       return new DeclarationBlock({})
         .export()
-        .asKind('function')
-        .withName(`${name}Schema(): z.ZodObject<Properties<${name}>>`)
-        .withBlock([indent(`return z.object({`), shape, indent('})')].join('\n')).string;
+        .asKind('const')
+        .withName(`${name}Schema: myzod.Type<${name}>`) //TODO: Test this
+        .withBlock([indent(`myzod.object({`), shape, indent('})')].join('\n')).string;
     },
     EnumTypeDefinition: (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(`z.enum([${node.values?.map(enumOption => `'${enumOption.name.value}'`).join(', ')}])`).string;
       }
-
+    */
       return new DeclarationBlock({})
         .export()
         .asKind('const')
         .withName(`${enumname}Schema`)
-        .withContent(`z.nativeEnum(${enumname})`).string;
+        .withContent(`myzod.enum(${enumname})`).string;
     },
   };
 };
 
-const generateInputObjectFieldZodSchema = (
+const generateInputObjectFieldMyZodSchema = (
   config: ValidationSchemaPluginConfig,
   tsVisitor: TsVisitor,
   schema: GraphQLSchema,
   field: InputValueDefinitionNode,
   indentCount: number
 ): string => {
-  const gen = generateInputObjectFieldTypeZodSchema(config, tsVisitor, schema, field, field.type);
+  const gen = generateInputObjectFieldTypeMyZodSchema(config, tsVisitor, schema, field, field.type);
   return indent(`${field.name.value}: ${maybeLazy(field.type, gen)}`, indentCount);
 };
 
-const generateInputObjectFieldTypeZodSchema = (
+const generateInputObjectFieldTypeMyZodSchema = (
   config: ValidationSchemaPluginConfig,
   tsVisitor: TsVisitor,
   schema: GraphQLSchema,
@@ -104,22 +113,22 @@ const generateInputObjectFieldTypeZodSchema = (
   parentType?: TypeNode
 ): string => {
   if (isListType(type)) {
-    const gen = generateInputObjectFieldTypeZodSchema(config, tsVisitor, schema, field, type.type, type);
+    const gen = generateInputObjectFieldTypeMyZodSchema(config, tsVisitor, schema, field, type.type, type);
     if (!isNonNullType(parentType)) {
-      const arrayGen = `z.array(${maybeLazy(type.type, gen)})`;
+      const arrayGen = `myzod.array(${maybeLazy(type.type, gen)})`;
       const maybeLazyGen = applyDirectives(config, field, arrayGen);
-      return `${maybeLazyGen}.nullish()`;
+      return `${maybeLazyGen}.optional()`; //  to make it equivalent to nullish: `${maybeLazyGen}.optional().optional().or(nullable())`;
     }
-    return `z.array(${maybeLazy(type.type, gen)})`;
+    return `myzod.array(${maybeLazy(type.type, gen)})`;
   }
   if (isNonNullType(type)) {
-    const gen = generateInputObjectFieldTypeZodSchema(config, tsVisitor, schema, field, type.type, type);
+    const gen = generateInputObjectFieldTypeMyZodSchema(config, tsVisitor, schema, field, type.type, type);
     return maybeLazy(type.type, gen);
   }
   if (isNamedType(type)) {
-    const gen = generateNameNodeZodSchema(config, tsVisitor, schema, type.name);
+    const gen = generateNameNodeMyZodSchema(config, tsVisitor, schema, type.name);
     if (isListType(parentType)) {
-      return `${gen}.nullable()`;
+      return `${gen}.nullable()`; //TODO: Test this later
     }
     const appliedDirectivesGen = applyDirectives(config, field, gen);
     if (isNonNullType(parentType)) {
@@ -130,14 +139,15 @@ const generateInputObjectFieldTypeZodSchema = (
       return appliedDirectivesGen;
     }
     if (isListType(parentType)) {
-      return `${appliedDirectivesGen}.nullable()`;
+      return `${appliedDirectivesGen}.nullable()`; //TODO: Test this later
     }
-    return `${appliedDirectivesGen}.nullish()`;
+    return `${appliedDirectivesGen}.optional()`; // to make it equivalent to nullish: `${appliedDirectivesGen}.optional().or(nullable())`;
   }
   console.warn('unhandled type:', type);
   return '';
 };
 
+// TODO: Find out how it works and implement it
 const applyDirectives = (
   config: ValidationSchemaPluginConfig,
   field: InputValueDefinitionNode,
@@ -150,7 +160,7 @@ const applyDirectives = (
   return gen;
 };
 
-const generateNameNodeZodSchema = (
+const generateNameNodeMyZodSchema = (
   config: ValidationSchemaPluginConfig,
   tsVisitor: TsVisitor,
   schema: GraphQLSchema,
@@ -173,7 +183,7 @@ const generateNameNodeZodSchema = (
 
 const maybeLazy = (type: TypeNode, schema: string): string => {
   if (isNamedType(type) && isInput(type.name.value)) {
-    return `z.lazy(() => ${schema})`;
+    return `myzod.lazy(() => ${schema})`;
   }
   return schema;
 };
@@ -185,11 +195,11 @@ const zod4Scalar = (config: ValidationSchemaPluginConfig, tsVisitor: TsVisitor,
   const tsType = tsVisitor.scalars[scalarName];
   switch (tsType) {
     case 'string':
-      return `z.string()`;
+      return `myzod.string()`;
     case 'number':
-      return `z.number()`;
+      return `myzod.number()`;
     case 'boolean':
-      return `z.boolean()`;
+      return `myzod.boolean()`;
   }
   console.warn('unhandled name:', scalarName);
   return anySchema;