gem-hunter

Installation

npm install @duplojs/zod-to-typescript zod

Usage

1. Import necessary modules

import { z as zod } from 'zod';
import { ZodToTypescript } from '@duplojs/zod-to-typescript';

2. Define Zod schema

const schema = zod.object({
  name: zod.string(),
  age: zod.number(),
  isStudent: zod.boolean(),
});

3. Convert Zod schema to TypeScript type

const options: ConvertOptions = {
    name: "User", // Optional: Specify a name for the TypeScript type
    export: true, // Optional: Export the TypeScript type
};

const tsType = ZodToTypescript.convert(userSchema, options);

4. Output the TypeScript type

console.log(tsType);
// output:
export type User = {
  name: string;
  age: number;
  isStudent: boolean;
};

5. Full Example

import { z as zod } from 'zod';
import { ZodToTypescript } from '@duplojs/zod-to-typescript';

const schema = zod.object({
  name: zod.string(),
  age: zod.number(),
  isStudent: zod.boolean(),
});

const options: ConvertOptions = {
    name: "User",
    export: true,
};

const tsType = ZodToTypescript.convert(schema, options);

console.log(tsType);
// Output: 
export type User = { 
    name: string; 
    age: number; 
    isStudent: boolean; 
};

6. Using Identifiers

import { ZodToTypescript, ConvertOptions } from "@duplojs/zod-to-typescript";
import { z as zod } from "zod";

// Define your schemas
const addressSchema = zod.object({
    street: zod.string(),
    city: zod.string(),
    zipCode: zod.string(),
});

const companySchema = zod.object({
    name: zod.string(),
    address: addressSchema,
}).identifier("Company"); // automatically identifies the schema as "Company"

const employeeSchema = zod.object({
    employeeId: zod.number(),
    name: zod.string(),
    position: zod.string(),
    company: companySchema,
})

// Convert the Employee schema to TypeScript
const options: ConvertOptions = {
    name: "Employee",
    identifiers: [
        {
            name: "Address", // define manually
            zodSchema: addressSchema,
        },
    ],
    export: true,
};

const tsType = ZodToTypescript.convert(employeeSchema, options);

console.log(tsType);
// Output:
export type Address = {
    street: string;
    city: string;
    zipCode: string;
};

export type Company = {
    name: string;
    address: Address;
};

export type Employee = {
    employeeId: number;
    name: string;
    position: string;
    company: Company;
};

7. Recursive Schemas

import { ZodToTypescript, ConvertOptions } from "@duplojs/zod-to-typescript";
import { z as zod } from "zod";

const categorySchema = zod.object({
    name: zod.string(),
    subcategories: zod.lazy(() => categorySchema.array()),
}).identifier("Category");

const tsType = ZodToTypescript.convert(categorySchema, { export: true });

console.log(tsType);
// Output:
export type Category = {
    name: string;
    subcategories: Category[];
};

8. New instance

import { ZodToTypescript } from "@duplojs/zod-to-typescript";
import { z as zod } from "zod";

const commentSchema = zod.object({
    user: zod.lazy<any>(() => userSchema),
    content: zod.string(),
}).identifier("Comment");

const postSchema = zod.object({
    title: zod.string(),
    content: zod.string(),
    date: zod.coerce.date(),
    comments: commentSchema.array(),
});

const userSchema = zod.object({
    userId: zod.number(),
    firstname: zod.string(),
    lastname: zod.string(),
    posts: postSchema.array(),
});

const ztt = new ZodToTypescript();

ztt.append(commentSchema);
ztt.append(userSchema, "User");
ztt.append(postSchema, "Post");

const tsType = ztt.toString()

console.log(tsType);
// Output:
type Comment = {
    user: User;
    content: string;
};

type User = {
    userId: number;
    firstname: string;
    lastname: string;
    posts: Post[];
};

type Post = {
    title: string;
    content: string;
    date: Date;
    comments: Comment[];
};

9. Hooks

import { ZodToTypescript } from "@duplojs/zod-to-typescript";
import { z as zod } from "zod";

const zodSchema = zod.object({
    prop1: zod.date(),
    prop2: zod.number(),
});

const tsType = ZodToTypescript.convert(
    zodSchema,
    {
        name: "Schema"
        zodSchemaHooks: [
            (zodSchema, context, output) => output(
                "next",
                zodSchema instanceof ZodNumber && zodSchema._def.coerce
                    ? zod.number().optional()
                    : zodSchema,
            ),
            (zodSchema, context, output) => output(
                "stop",
                zodSchema instanceof ZodDate ? zod.string() : zodSchema,
            ),
        ],
    },
);

console.log(tsType);
// Output:
type Schema = {
    prop1: string;
    prop2?: number | undefined;
};

10. Override type node

import { ZodToTypescript } from "@duplojs/zod-to-typescript";
import { z as zod } from "zod";
import { factory } from "typescript";

const zodSchema = zod.string().overrideTypeNode(
    factory.createTypeReferenceNode(factory.createIdentifier("RegExp")),
);
// or
const zodSchema = zod.string().overrideTypeNode(
    (ts) => ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("RegExp")),
);

const tsType = ZodToTypescript.convert(
    zodSchema,
    {
        name: "MySchema"
    }
);

console.log(tsType);
// Output:
type MySchema = RegExp;

More Examples

Acknowledgements