zod-to-drizzle

Convert Zod schemas to Drizzle ORM tables with TypeScript support.

Features

• 🚀 Convert Zod schemas to Drizzle tables
• 🔑 Automatic primary key handling
• 🔗 Type-safe foreign key references
• 📝 Full TypeScript support
• 🎯 Support for SQLite (PostgreSQL & MySQL coming soon)
• 🎨 Support for all common Zod types

Installation

1bun add zod-to-drizzle
2# or
3npm install zod-to-drizzle
4# or
5pnpm add zod-to-drizzle
6# or
7yarn add zod-to-drizzle

Quick Start

1import { createTableFromZod } from "zod-to-drizzle";
2import { z } from "zod";
3import { SQLiteTable } from "drizzle-orm/sqlite-core";
4
5// Define your schema
6const UserSchema = z.object({
7  id: z.number(),
8  name: z.string(),
9  email: z.string().email().optional(),
10  createdAt: z.number().default(Date.now),
11});
12
13// Create a table
14const users = createTableFromZod("users", UserSchema, {
15  dialect: "sqlite",
16  primaryKey: "id",
17}) as SQLiteTable;

Foreign Keys

1// Define schemas
2const UserSchema = z.object({
3  id: z.number(),
4  name: z.string(),
5});
6
7const PostSchema = z.object({
8  id: z.number(),
9  title: z.string(),
10  userId: z.number(),
11});
12
13// Create tables with references
14const users = createTableFromZod("users", UserSchema, {
15  dialect: "sqlite",
16  primaryKey: "id",
17});
18
19const posts = createTableFromZod("posts", PostSchema, {
20  dialect: "sqlite",
21  primaryKey: "id",
22  references: [
23    {
24      table: users,
25      columns: [["userId", "id"]],
26    },
27  ],
28});

Supported Types

Zod Type	SQLite	PostgreSQL	MySQL
z.string()	✅	🔜	🔜
z.number()	✅	🔜	🔜
z.boolean()	✅	🔜	🔜
z.date()	✅	🔜	🔜
z.enum()	✅	🔜	🔜
z.object() (JSON)	✅	🔜	🔜
z.array() (JSON)	✅	🔜	🔜
z.optional()	✅	🔜	🔜
z.nullable()	✅	🔜	🔜
z.default()	✅	🔜	🔜

API Reference

createTableFromZod

1function createTableFromZod<T extends z.ZodObject<any>>(
2  tableName: string,
3  schema: T,
4  options: {
5    dialect?: "sqlite" | "postgres" | "mysql";
6    primaryKey?: keyof z.infer<T>;
7    references?: Array<{
8      table: SQLiteTable;
9      columns: [keyof z.infer<T>, string][];
10    }>;
11  },
12);

Parameters

• tableName: The name of the table
• schema: Zod object schema
• options:
  • dialect: Database dialect (default: "sqlite")
  • primaryKey: Column to use as primary key
  • references: Array of foreign key references

Examples

Common Schema Pattern

1const CommonSchema = z.object({
2  id: z.number(),
3  createdAt: z.number().default(Date.now()),
4  updatedAt: z.number().nullish(),
5  deletedAt: z.number().nullish(),
6  createdBy: z.number(),
7  updatedBy: z.number().nullish(),
8  deletedBy: z.number().nullish(),
9  deleted: z.boolean().default(false),
10});
11
12const UserSchema = CommonSchema.extend({
13  name: z.string(),
14  email: z.string().email(),
15  role: z.enum(["admin", "user"]),
16});
17
18const users = createTableFromZod("users", UserSchema, {
19  dialect: "sqlite",
20  primaryKey: "id",
21});

Complex Types

1const Schema = z.object({
2  id: z.number(),
3  metadata: z.object({ key: z.string() }), // Stored as JSON (TEXT in SQLite)
4  tags: z.array(z.string()), // Stored as JSON (TEXT in SQLite)
5  settings: z.record(z.string()), // Stored as JSON (TEXT in SQLite)
6  role: z.enum(["admin", "user"]), // Stored as text
7});

Contributing

See CONTRIBUTING.md for details on how to contribute to this project.

License

Apache-2.0 - see LICENSE for details.