add some drafts

Author: dvv

src/config.ts

@@ -62,6 +62,13 @@ export type Config = {
    */
   skipParseJSDoc?: boolean;
 
+  /**
+   * Generated file header
+   *
+   * @default "// Generated by ts-to-zod\nimport { z } from \"zod\";"
+   */
+  headerText?: string;
+
   /**
    * Path of z.infer<> types file.
    */

src/config.zod.ts

@@ -30,6 +30,7 @@ export const configSchema = z.object({
   getSchemaName: getSchemaNameSchema.optional(),
   keepComments: z.boolean().optional().default(false),
   skipParseJSDoc: z.boolean().optional().default(false),
+  headerText: z.string().default("// Generated by ts-to-zod\nimport { z } from \"zod\";"),
   inferredTypes: z.string().optional(),
 });
 

src/core/generate.ts

@@ -48,6 +48,13 @@ export interface GenerateProps {
    */
   skipParseJSDoc?: boolean;
 
+  /**
+   * Generated file header
+   *
+   * @default "// Generated by ts-to-zod\nimport { z } from \"zod\";"
+   */
+  headerText?: string;
+
   /**
    * Path of z.infer<> types file.
    */
@@ -66,6 +73,8 @@ export function generate({
   getSchemaName = (id) => camel(id) + "Schema",
   keepComments = false,
   skipParseJSDoc = false,
+  headerText = `// Generated by ts-to-zod
+import { z } from "z";`
 }: GenerateProps) {
   // Create a source file and deal with modules
   const sourceFile = resolveModules(sourceText);
@@ -234,8 +243,7 @@ ${Array.from(zodSchemasWithMissingDependencies).join("\n")}`
   const imports = Array.from(typeImports.values());
   const getZodSchemasFile = (
     typesImportPath: string
-  ) => `// Generated by ts-to-zod
-import { z } from "zod";
+  ) => `${headerText}
 ${
   imports.length
     ? `import { ${imports.join(", ")} } from "${typesImportPath}";\n`
@@ -258,8 +266,7 @@ ${Array.from(statements.values())
   const getIntegrationTestFile = (
     typesImportPath: string,
     zodSchemasImportPath: string
-  ) => `// Generated by ts-to-zod
-import { z } from "zod";
+  ) => `${headerText}
 
 import * as spec from "${typesImportPath}";
 import * as generated from "${zodSchemasImportPath}";
@@ -288,8 +295,7 @@ ${testCases.map(print).join("\n")}
 
   const getInferredTypes = (
     zodSchemasImportPath: string
-  ) => `// Generated by ts-to-zod
-import { z } from "zod";
+  ) => `${headerText}
 
 import * as generated from "${zodSchemasImportPath}";
 

src/core/generateZodSchema.ts

@@ -69,15 +69,13 @@ export function generateZodSchemaVariableStatement({
     | ts.CallExpression
     | ts.Identifier
     | ts.PropertyAccessExpression
+    | ts.ArrowFunction
     | undefined;
   let dependencies: string[] = [];
   let requiresImport = false;
 
   if (ts.isInterfaceDeclaration(node)) {
     let schemaExtensionClauses: string[] | undefined;
-    if (node.typeParameters) {
-      throw new Error("Interface with generics are not supported!");
-    }
     if (node.heritageClauses) {
       // Looping on heritageClauses browses the "extends" keywords
       schemaExtensionClauses = node.heritageClauses.reduce(
@@ -111,9 +109,6 @@ export function generateZodSchemaVariableStatement({
   }
 
   if (ts.isTypeAliasDeclaration(node)) {
-    if (node.typeParameters) {
-      throw new Error("Type with generics are not supported!");
-    }
     const jsDocTags = skipParseJSDoc ? {} : getJSDocTags(node, sourceFile);
 
     schema = buildZodPrimitive({
@@ -133,6 +128,39 @@ export function generateZodSchemaVariableStatement({
     requiresImport = true;
   }
 
+  // process generic dependencies
+  if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+    if (schema !== undefined && node.typeParameters) {
+      const genericTypes = node
+        .typeParameters.map((p) => `${p.name.escapedText}`)
+      const genericDependencies = genericTypes.map((p) => getDependencyName(p))
+      dependencies = dependencies
+        .filter((dep) => !genericDependencies.includes(dep));
+      schema = f.createArrowFunction(
+        undefined,
+        genericTypes.map((dep) => f.createIdentifier(dep)),
+        genericTypes.map((dep) => f.createParameterDeclaration(
+          undefined,
+          undefined,
+          undefined,
+          f.createIdentifier(getDependencyName(dep)),
+          undefined,
+          f.createTypeReferenceNode(
+            f.createQualifiedName(
+              f.createIdentifier(zodImportValue),
+              f.createIdentifier(`ZodSchema<${dep}> = z.any()`)
+            ),
+            undefined
+          ),
+          undefined
+        )),
+        undefined,
+        f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+        schema
+      );
+    }
+  }
+
   return {
     dependencies: uniq(dependencies),
     statement: f.createVariableStatement(
@@ -205,7 +233,37 @@ function buildZodProperties({
   return properties;
 }
 
-function buildZodPrimitive({
+// decorate builder to allow for schema appending/overriding
+function buildZodPrimitive(opts: {
+  z: string;
+  typeNode: ts.TypeNode;
+  isOptional: boolean;
+  isNullable?: boolean;
+  isPartial?: boolean;
+  isRequired?: boolean;
+  jsDocTags: JSDocTags;
+  sourceFile: ts.SourceFile;
+  dependencies: string[];
+  getDependencyName: (identifierName: string) => string;
+  skipParseJSDoc: boolean;
+}) {
+  const schema = opts.jsDocTags.schema
+  delete opts.jsDocTags.schema
+  const generatedSchema = _buildZodPrimitive(opts);
+  // schema not specified? return generated one
+  if (!schema) return generatedSchema;
+  // schema starts with dot? append it
+  if (schema.startsWith(".")) {
+    return f.createPropertyAccessExpression(generatedSchema, f.createIdentifier(schema.slice(1)));
+  }
+  // otherwise use schema verbatim
+  return f.createPropertyAccessExpression(
+    f.createIdentifier(opts.z),
+    f.createIdentifier(schema)
+  );
+}
+
+function _buildZodPrimitive({
   z,
   typeNode,
   isOptional,
@@ -493,6 +551,18 @@ function buildZodPrimitive({
 
     const nodes = typeNode.types.filter(isNotNull);
 
+    // string-only enum? issue z.enum
+    if (typeNode.types.every((i) =>
+      ts.isLiteralTypeNode(i) && i.literal.kind === ts.SyntaxKind.StringLiteral
+    )) {
+      return buildZodSchema(
+        z,
+        "enum",
+        [f.createArrayLiteralExpression(nodes.map((i) => (i as any)["literal"]))],
+        zodProperties
+      );
+    }
+
     // type A = | 'b' is a valid typescript definition
     // Zod does not allow `z.union(['b']), so we have to return just the value
     if (nodes.length === 1) {
@@ -530,10 +600,16 @@ function buildZodPrimitive({
       });
     }
 
+    // discriminator specified? use discriminatedUnion
     return buildZodSchema(
       z,
-      "union",
-      [f.createArrayLiteralExpression(values)],
+      jsDocTags.discriminator !== undefined
+        ? "discriminatedUnion"
+        : "union",
+      jsDocTags.discriminator !== undefined
+        ? [f.createStringLiteral(jsDocTags.discriminator),
+           f.createArrayLiteralExpression(values)]
+        : [f.createArrayLiteralExpression(values)],
       zodProperties
     );
   }

src/core/jsDocTags.ts

@@ -30,6 +30,8 @@ export interface JSDocTags {
   maxLength?: TagWithError<number>;
   format?: TagWithError<typeof formats[-1]>;
   pattern?: string;
+  discriminator?: string;
+  schema?: string;
 }
 
 /**
@@ -46,6 +48,8 @@ function isJSDocTagKey(tagName: string): tagName is keyof JSDocTags {
     "maxLength",
     "format",
     "pattern",
+    "discriminator",
+    "schema",
   ];
   return (keys as string[]).includes(tagName);
 }
@@ -142,6 +146,16 @@ export function getJSDocTags(nodeType: ts.Node, sourceFile: ts.SourceFile) {
               jsDocTags[tagName] = tag.comment;
             }
             break;
+          case "discriminator":
+            if (tag.comment) {
+              jsDocTags[tagName] = tag.comment;
+            }
+            break;
+          case "schema":
+            if (tag.comment) {
+              jsDocTags[tagName] = tag.comment;
+            }
+            break;
         }
       });
     });

src/utils/getImportPath.ts

@@ -12,5 +12,6 @@ export function getImportPath(from: string, to: string) {
   const relativePath = slash(relative(from, to).slice(1));
   const { dir, name } = parse(relativePath);
 
-  return `${dir}/${name}`;
+  // NB: import from the full path
+  return `${dir}/${name}.ts`;
 }