Supazod

Generate Zod schemas from Typescript types generated by the Supabase CLI.

Quick Start

``sh
$ pnpm add --D supazod
$ supabase gen types typescript --local > types.ts

Generate schemas with separate types file

$ pnpm supazod -i types.ts -o schemas.ts -t schemas.d.ts -s public,schema_a,schema_b

Or generate everything in a single file with inline types

$ pnpm supazod -i types.ts -o schemas.ts --inline-types
`

That's it! Check your schemas.ts file - you should have Zod schemas generated for all your tables, views, enums and functions.

$3

PowerShell's > redirect operator outputs UTF-16 by default, which supazod cannot read. Use Out-File with -Encoding utf8 instead:

`powershell


Local database

supabase gen types typescript --local | Out-File -FilePath types.ts -Encoding utf8

From supabase.com

supabase gen types typescript --project-id | Out-File -FilePath types.ts -Encoding utf8
`

Generated Output

Supazod generates clean, consistent schema names:

`typescript
// ✅ Clean naming (v2.0+)
export const publicUsersInsertSchema = z.object({...});
export const publicUsersUpdateSchema = z.object({...});
export const publicUserStatusSchema = z.union([...]);
export const publicGetStatusArgsSchema = z.object({...});

// TypeScript types without "Schema" suffix
export type PublicUsersInsert = z.infer;
export type PublicUserStatus = z.infer;
`

Inline Types

Use --inline-types (or -I) to generate both Zod schemas and TypeScript types in a single file:

`sh
$ pnpm supazod -i types.ts -o schemas.ts --inline-types
`

This generates a single schemas.ts file with everything included:

`typescript
// schemas.ts - single file output
import { z } from "zod";

export const publicUsersRowSchema = z.object({
id: z.number(),
username: z.string(),
// ...
});

export const publicUserStatusSchema = z.union([
z.literal("ONLINE"),
z.literal("OFFLINE"),
]);

// Types are included directly in the same file
export type PublicUsersRow = z.infer;
export type PublicUserStatus = z.infer;
`

This is useful when you prefer a simpler setup without managing separate .d.ts files.

You can also enable this via the config file:

`typescript
// supazod.config.ts
import { defineConfig } from 'supazod';

export default defineConfig({
inlineTypes: true,
});
`

Configuration

$3

Create a supazod.config.ts file for type-safe configuration with IntelliSense:

`typescript
import { defineConfig } from 'supazod';

export default defineConfig({
namingConfig: {
// TypeScript provides autocomplete for placeholders:
// {schema}, {table}, {operation}, {function}, {name}
tableOperationPattern: '{schema}_{table}_{operation}',
tableSchemaPattern: '{schema}{table}{operation}',
enumPattern: '{schema}_{name}_Enum',
enumSchemaPattern: '{schema}{name}',
functionArgsPattern: '{schema}_{function}_Args',
functionArgsSchemaPattern: '{schema}{function}Args',
functionReturnsPattern: '{schema}_{function}_Returns',
functionReturnsSchemaPattern: '{schema}{function}Returns',

// Capitalization and formatting
capitalizeSchema: true,
capitalizeNames: true,
separator: '_',
}
});
`

$3

`json
{
"namingConfig": {
"tableOperationPattern": "{schema}_{table}_{operation}",
"tableSchemaPattern": "{schema}{table}{operation}",
"enumPattern": "{schema}_{name}_Enum",
"enumSchemaPattern": "{schema}{name}",
"capitalizeSchema": true,
"capitalizeNames": true,
"separator": "_"
}
}
`

Supported config files:
- supazod.config.ts (recommended)
- supazod.config.js
- supazod.config.json
- .supazodrc.ts
- .supazodrc.js
- .supazodrc.json

CLI Options

`sh
supazod [options]

-i, --input Input TypeScript file
-o, --output Output Zod schemas file
-t, --types-output Output type definitions (optional)
-s, --schema Schema to process (optional, defaults to all)
-I, --inline-types Include types in schema file (no separate .d.ts)
-v, --verbose Enable debug logs

Naming Configuration (overrides config file)


--table-operation-pattern Pattern for table operations
--table-schema-pattern Pattern for table schema constants
--enum-pattern Pattern for enums
--enum-schema-pattern Pattern for enum schema constants
--function-args-pattern Pattern for function arguments
--function-args-schema-pattern Pattern for function arg schema constants
--function-returns-pattern Pattern for function returns
--function-returns-schema-pattern Pattern for function return schema constants
--config Path to a Supazod config file
--capitalize-schema Capitalize schema names
--capitalize-names Capitalize type names
--separator Separator between name parts
`

$3

`sh


Generate with custom naming patterns


$ pnpm supazod -i types.ts -o schemas.ts \
--table-operation-pattern '{schema}_{table}_{operation}' \
--table-schema-pattern '{schema}{table}{operation}' \
--enum-pattern '{schema}_{name}_Enum' \
--enum-schema-pattern '{schema}{name}' \
--separator '_'
`

$3

For each naming pattern there is an optional companion for the generated Zod schema constants (for example tableSchemaPattern).
Use these when you want custom suffixes on TypeScript types without affecting the schema identifiers that appear in schemas.ts.

Patterns now preserve any separators you include (like _ or -) in the emitted type aliases and schema constants, so you can rely on the exact formatting you configure.

Available Placeholders

- {schema} - Database schema name (e.g., "public", "auth")
- {table} - Table name (e.g., "users", "posts")
- {operation} - Operation type ("Insert", "Update", "Row")
- {function} - Function name (e.g., "get_status")
- {name} - Type name (e.g., "user_status" for enums)

Features

- 🎯 Complete Coverage: Full support for tables, views, enums, functions and composite types
- 🔧 Multi-Schema: Process multiple database schemas with a single command
- 📦 Type Declarations: Generate corresponding .d.ts files alongside Zod schemas
- 📄 Inline Types: Option to include types directly in the schema file (--inline-types)
- ⚙️ Type-Safe Configuration: TypeScript config with IntelliSense support
- 🏷️ Flexible Naming: Customizable naming patterns with placeholders
- ✨ Clean Output: Fixed schema naming (no more "SchemaSchema" duplication)

Programmatic API

`typescript
import { generateContent } from 'supazod';

const result = await generateContent({
input: './types.ts',
output: './schema.ts',
schema: ['public'],
inlineTypes: true, // Include types in schema file
namingConfig: {
tableOperationPattern: '{schema}_{table}_{operation}',
enumPattern: '{schema}_{name}_Enum',
}
});
`

Migration from v1.x

If upgrading from v1.x, see MIGRATION.md for detailed migration instructions. The main changes:

- ✅ Fixed duplicated "Schema" suffixes (publicUsersInsertSchemaSchema → publicUsersInsertSchema`)
- ✅ Clean TypeScript type names (removed "Schema" suffix from types)
- ✅ New type-safe configuration system

Credits

This project started as a fork of supabase-to-zod by @psteinroe. While maintaining the original concept, the codebase has been completely rewritten to provide better performance, enhanced type safety, and a more robust architecture. Thanks to psteinroe for the initial inspiration! 💚