kysely-codegen generates Kysely type definitions from your database. That's it.

Table of contents

• Installation
• Generating type definitions
• Include/exclude patterns
• Help
• Using the type definitions
• Issue funding

Installation

npm install --save-dev kysely-codegen

You will also need to install Kysely with your driver of choice:

# PostgreSQL
npm install kysely pg

# MySQL
npm install kysely mysql2

# SQLite
npm install kysely better-sqlite3

# MSSQL
npm install kysely tedious tarn @tediousjs/connection-string

# LibSQL
npm install @libsql/kysely-libsql

Generating type definitions

The most convenient way to get started is to create an .env file with your database connection string:

# PostgreSQL
DATABASE_URL=postgres://username:password@yourdomain.com/database

# MySQL
DATABASE_URL=mysql://username:password@yourdomain.com/database

# SQLite
DATABASE_URL=C:/Program Files/sqlite3/db

# MSSQL
DATABASE_URL=Server=mssql;Database=database;User Id=user;Password=password

# LibSQL
DATABASE_URL=libsql://token@host:port/database

If your URL contains a password with special characters, those characters may need to be percent-encoded.

If you are using PlanetScale, make sure your URL contains this SSL query string parameter: ssl={"rejectUnauthorized":true}

Then run:

kysely-codegen

This command will generate a .d.ts file from your database, for example:

import { 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 Timestamp = ColumnType<Date, Date | string, Date | string>;

export interface Company {
  id: Generated<number>;
  name: string;
}

export interface User {
  company_id: number | null;
  created_at: Generated<Timestamp>;
  email: string;
  id: Generated<number>;
  is_active: boolean;
  name: string;
  updated_at: Timestamp;
}

export interface DB {
  company: Company;
  user: User;
}

Include/exclude patterns

You can choose which tables should be included during code generation by providing a glob pattern to the --include-pattern and --exclude-pattern flags. We use micromatch under the hood which provides advanced glob support. For instance, if you only want to include your public tables:

kysely-codegen --include-pattern="public.*"

You can also include only certain tables within a schema:

kysely-codegen --include-pattern="public.+(user|post)"

Or exclude an entire class of tables:

kysely-codegen --exclude-pattern="documents.*"

Help

For more options, run kysely-codegen --help.

Using the type definitions

Import DB into new Kysely<DB>, and you're done!

import { Kysely, PostgresDialect } from 'kysely';
import { DB } from 'kysely-codegen';
import { Pool } from 'pg';

const db = new Kysely<DB>({
  dialect: new PostgresDialect({
    pool: new Pool({
      connectionString: process.env.DATABASE_URL,
    }),
  }),
});

const rows = await db.selectFrom('user').selectAll().execute();
//    ^ { company_id: number | null; created_at: Date; email: string; id: number; ... }[]

Issue funding

We use Polar.sh to upvote and promote specific features that you would like to see implemented. Check the backlog and help out: