before implementing myzod

Author: Parables

package.json

@@ -52,6 +52,7 @@
     "@typescript-eslint/parser": "^5.10.0",
     "eslint": "^8.7.0",
     "jest": "^27.4.7",
+    "myzod": "^1.8.7",
     "npm-run-all": "^4.1.5",
     "prettier": "2.5.1",
     "ts-jest": "^27.1.3",

src/myzod/index.ts

@@ -0,0 +1,196 @@
+import { isInput, isNonNullType, isListType, isNamedType } from './../graphql';
+import { ValidationSchemaPluginConfig } from '../config';
+import {
+  InputValueDefinitionNode,
+  NameNode,
+  TypeNode,
+  GraphQLSchema,
+  InputObjectTypeDefinitionNode,
+  EnumTypeDefinitionNode,
+} from 'graphql';
+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 anySchema = `definedNonNullAnySchema`;
+
+export const ZodSchemaVisitor = (schema: GraphQLSchema, config: ValidationSchemaPluginConfig) => {
+  const tsVisitor = new TsVisitor(schema, config);
+
+  const importTypes: string[] = [];
+
+  return {
+    buildImports: (): string[] => {
+      if (config.importFrom && importTypes.length > 0) {
+        return [importZod, `import { ${importTypes.join(', ')} } from '${config.importFrom}'`];
+      }
+      return [importZod];
+    },
+    initialEmit: (): string =>
+      '\n' +
+      [
+        new DeclarationBlock({})
+          .asKind('type')
+          .withName('Properties<T>')
+          .withContent(['Required<{', '  [K in keyof T]: z.ZodType<T[K], any, T[K]>;', '}>'].join('\n')).string,
+        // 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
+        new DeclarationBlock({}).asKind('type').withName('definedNonNullAny').withContent('{}').string,
+        new DeclarationBlock({})
+          .export()
+          .asKind('const')
+          .withName(`isDefinedNonNullAny`)
+          .withContent(`(v: any): v is definedNonNullAny => v !== undefined && v !== null`).string,
+        new DeclarationBlock({})
+          .export()
+          .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))
+        .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;
+    },
+    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;
+    },
+  };
+};
+
+const generateInputObjectFieldZodSchema = (
+  config: ValidationSchemaPluginConfig,
+  tsVisitor: TsVisitor,
+  schema: GraphQLSchema,
+  field: InputValueDefinitionNode,
+  indentCount: number
+): string => {
+  const gen = generateInputObjectFieldTypeZodSchema(config, tsVisitor, schema, field, field.type);
+  return indent(`${field.name.value}: ${maybeLazy(field.type, gen)}`, indentCount);
+};
+
+const generateInputObjectFieldTypeZodSchema = (
+  config: ValidationSchemaPluginConfig,
+  tsVisitor: TsVisitor,
+  schema: GraphQLSchema,
+  field: InputValueDefinitionNode,
+  type: TypeNode,
+  parentType?: TypeNode
+): string => {
+  if (isListType(type)) {
+    const gen = generateInputObjectFieldTypeZodSchema(config, tsVisitor, schema, field, type.type, type);
+    if (!isNonNullType(parentType)) {
+      const arrayGen = `z.array(${maybeLazy(type.type, gen)})`;
+      const maybeLazyGen = applyDirectives(config, field, arrayGen);
+      return `${maybeLazyGen}.nullish()`;
+    }
+    return `z.array(${maybeLazy(type.type, gen)})`;
+  }
+  if (isNonNullType(type)) {
+    const gen = generateInputObjectFieldTypeZodSchema(config, tsVisitor, schema, field, type.type, type);
+    return maybeLazy(type.type, gen);
+  }
+  if (isNamedType(type)) {
+    const gen = generateNameNodeZodSchema(config, tsVisitor, schema, type.name);
+    if (isListType(parentType)) {
+      return `${gen}.nullable()`;
+    }
+    const appliedDirectivesGen = applyDirectives(config, field, gen);
+    if (isNonNullType(parentType)) {
+      if (config.notAllowEmptyString === true) {
+        const tsType = tsVisitor.scalars[type.name.value];
+        if (tsType === 'string') return `${gen}.min(1)`;
+      }
+      return appliedDirectivesGen;
+    }
+    if (isListType(parentType)) {
+      return `${appliedDirectivesGen}.nullable()`;
+    }
+    return `${appliedDirectivesGen}.nullish()`;
+  }
+  console.warn('unhandled type:', type);
+  return '';
+};
+
+const applyDirectives = (
+  config: ValidationSchemaPluginConfig,
+  field: InputValueDefinitionNode,
+  gen: string
+): string => {
+  if (config.directives && field.directives) {
+    const formatted = formatDirectiveConfig(config.directives);
+    return gen + buildApi(formatted, field.directives);
+  }
+  return gen;
+};
+
+const generateNameNodeZodSchema = (
+  config: ValidationSchemaPluginConfig,
+  tsVisitor: TsVisitor,
+  schema: GraphQLSchema,
+  node: NameNode
+): string => {
+  const typ = schema.getType(node.value);
+
+  if (typ && typ.astNode?.kind === 'InputObjectTypeDefinition') {
+    const enumName = tsVisitor.convertName(typ.astNode.name.value);
+    return `${enumName}Schema()`;
+  }
+
+  if (typ && typ.astNode?.kind === 'EnumTypeDefinition') {
+    const enumName = tsVisitor.convertName(typ.astNode.name.value);
+    return `${enumName}Schema`;
+  }
+
+  return zod4Scalar(config, tsVisitor, node.value);
+};
+
+const maybeLazy = (type: TypeNode, schema: string): string => {
+  if (isNamedType(type) && isInput(type.name.value)) {
+    return `z.lazy(() => ${schema})`;
+  }
+  return schema;
+};
+
+const zod4Scalar = (config: ValidationSchemaPluginConfig, tsVisitor: TsVisitor, scalarName: string): string => {
+  if (config.scalarSchemas?.[scalarName]) {
+    return config.scalarSchemas[scalarName];
+  }
+  const tsType = tsVisitor.scalars[scalarName];
+  switch (tsType) {
+    case 'string':
+      return `z.string()`;
+    case 'number':
+      return `z.number()`;
+    case 'boolean':
+      return `z.boolean()`;
+  }
+  console.warn('unhandled name:', scalarName);
+  return anySchema;
+};

yarn.lock

@@ -4321,6 +4321,11 @@ [email protected]:
   resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d"
   integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==
 
+myzod@^1.8.7:
+  version "1.8.7"
+  resolved "https://registry.yarnpkg.com/myzod/-/myzod-1.8.7.tgz#f7e1d5379b517de039729735a8578a550c562292"
+  integrity sha512-H/Nmst+ZIGQppKVeOq6ufieRnnK0u+UfDLgCrG1Rtn6W/GzMoz6Ur9/iLBwB0N8s6ZE/4hhbRTUt3Pg7nH4X2Q==
+
 nanoclone@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/nanoclone/-/nanoclone-0.2.1.tgz#dd4090f8f1a110d26bb32c49ed2f5b9235209ed4"