kysely-gen

Generate TypeScript types from your database for Kysely.

Supports PostgreSQL, MySQL, SQLite, and MSSQL.

Install

# PostgreSQL
npm install kysely-gen kysely pg

# MySQL
npm install kysely-gen kysely mysql2

# SQLite
npm install kysely-gen kysely better-sqlite3

# MSSQL
npm install kysely-gen kysely tedious tarn

Usage

# PostgreSQL (auto-detected from URL)
DATABASE_URL=postgres://user:pass@localhost:5432/db npx kysely-gen

# MySQL (auto-detected from URL)
DATABASE_URL=mysql://user:pass@localhost:3306/db npx kysely-gen

# SQLite (auto-detected from file extension)
npx kysely-gen --url ./database.db

# MSSQL (auto-detected from URL or connection string)
npx kysely-gen --url "mssql://user:pass@localhost:1433/db"
npx kysely-gen --url "Server=localhost;Database=db;User Id=user;Password=pass"

# Explicit dialect
npx kysely-gen --dialect mysql --url mysql://user:pass@localhost:3306/db

Options

Option	Description
--dialect <name>	Database dialect: postgres, mysql, sqlite, or mssql (auto-detected)
--out <path>	Output file (default: ./db.d.ts)
--schema <name>	Schema to introspect (repeatable)
--url <string>	Database URL (overrides DATABASE_URL)
--camel-case	Convert names to camelCase
--include-pattern <glob>	Only include matching tables
--exclude-pattern <glob>	Exclude matching tables
--zod	Generate Zod schemas instead of TypeScript interfaces
--no-boolean-coerce	Output 0 | 1 instead of coercing to boolean for CHECK constraints

Zod Schema Generation

Generate Zod validation schemas with inferred types instead of TypeScript interfaces. Requires Zod v4+:

npm install zod@4
npx kysely-gen --zod

This generates db-schemas.ts with Zod schemas and inferred types:

import { z } from 'zod';

export const userSchema = z.object({
  id: z.number(),
  email: z.string(),
  name: z.string().nullable(),
  createdAt: z.date(),
});

export const newUserSchema = z.object({
  id: z.number().optional(),
  email: z.string(),
  name: z.string().nullable().optional(),
  createdAt: z.union([z.date(), z.string()]).optional(),
});

export const userUpdateSchema = z.object({
  id: z.number().optional(),
  email: z.string().optional(),
  name: z.string().nullable().optional(),
  createdAt: z.union([z.date(), z.string()]).optional(),
});

export type User = z.infer<typeof userSchema>;
export type NewUser = z.infer<typeof newUserSchema>;
export type UserUpdate = z.infer<typeof userUpdateSchema>;

Three schemas are generated per table:

• Select schema (userSchema): What you get from queries
• Insert schema (newUserSchema): For inserts - auto-increment/default columns are optional
• Update schema (userUpdateSchema): For updates - all columns are optional

The --zod flag replaces TypeScript interface generation. Types are inferred from schemas via z.infer<>, ensuring they never drift.

Example

kysely-gen --out ./src/db.d.ts --camel-case

Generates:

import type { ColumnType } from 'kysely';

export type Generated<T> = T extends ColumnType<infer S, infer I, infer U>
  ? ColumnType<S, I | undefined, U>
  : ColumnType<T, T | undefined, T>;

export type Status = 'pending' | 'approved' | 'rejected';

export interface User {
  id: Generated<number>;
  email: string;
  status: Status;
  createdAt: ColumnType<Date, Date | string, Date | string>;
}

export interface DB {
  users: User;
}

Features

PostgreSQL

• Enums mapped to union types
• ColumnType for select/insert/update type differences
• Generated<T> for auto-increment and default columns
• Materialized views, domains, partitioned tables
• Array columns

MySQL

• Enums parsed from column definitions
• ColumnType for timestamps, bigint, decimal
• Generated<T> for auto_increment columns
• Views
• Geometry types (Point, LineString, Polygon)
• tinyint(1) mapped to boolean

SQLite

• Generated<T> for INTEGER PRIMARY KEY (auto-increment)
• Views
• JSON columns mapped to JsonValue
• Simple type affinity mapping (no ColumnType wrappers)

MSSQL

• Generated<T> for identity and computed columns
• Views
• Multi-schema support (default: dbo)
• All MSSQL types: uniqueidentifier, datetime2, datetimeoffset, money, xml, varbinary, etc.
• Both URL (mssql://) and ADO.NET connection string formats

Boolean Coercion (SQLite/MSSQL)

SQLite and MSSQL store booleans as integers (0/1). When a CHECK(col IN (0, 1)) constraint is detected, kysely-gen generates:

TypeScript: boolean Zod: z.coerce.boolean()

Use --no-boolean-coerce to output raw 0 | 1 instead:

kysely-gen --zod --no-boolean-coerce

Type Mappings

Types are generated to match the default behavior of each database driver. If you customize your driver's type parsers, the generated types may not match.

PostgreSQL

Generated types match node-postgres (pg) defaults:

• Dates (timestamp, date): Driver returns Date objects. Inserts accept Date | string.
• Bigint (int8): Driver returns string (JS Number can't represent full int8 range). Inserts accept string | number | bigint.
• Numeric (numeric, decimal): Driver returns string for precision. Inserts accept string | number.

PostgreSQL	TypeScript
int2, int4, integer	number
int8, bigint	ColumnType<string, string | number | bigint, ...>
numeric, decimal	ColumnType<string, number | string, ...>
timestamp, date	ColumnType<Date, Date | string, ...>
jsonb, json	JsonValue
text[], int4[]	string[], number[]

MySQL

Generated types match mysql2 defaults:

• Dates (datetime, timestamp): Driver returns Date objects. Inserts accept Date | string.
• Bigint: Driver returns string. Inserts accept string | number | bigint.
• Decimal: Driver returns string for precision. Inserts accept string | number.

MySQL	TypeScript
tinyint(1)	boolean
int, smallint	number
bigint	ColumnType<string, string | number | bigint, ...>
decimal	ColumnType<string, number | string, ...>
datetime, timestamp	ColumnType<Date, Date | string, ...>
json	JsonValue
point	Point
enum('a','b')	'a' | 'b'

SQLite

Generated types match better-sqlite3 defaults. SQLite has simpler type affinity - no ColumnType wrappers needed since values are returned as-is.

SQLite	TypeScript
INTEGER, INT, BIGINT	number
REAL, DOUBLE, FLOAT	number
TEXT, VARCHAR, CHAR	string
BLOB	Buffer
DATE, DATETIME, TIMESTAMP	string
JSON	JsonValue
BOOLEAN	number (0/1)

MSSQL

Generated types match tedious defaults. The driver handles type conversions, so simple types are used without ColumnType wrappers.

MSSQL	TypeScript
int, smallint, tinyint, bigint	number
decimal, numeric, money, smallmoney	number
float, real	number
datetime, datetime2, date, time	Date
datetimeoffset, smalldatetime	Date
char, varchar, nchar, nvarchar	string
text, ntext	string
uniqueidentifier	string
xml	string
bit	boolean
binary, varbinary, image	Buffer
sql_variant	unknown

License

MIT