SQL to Kysely Type Generator

What is SQL to Kysely Type Generator?

Kysely is a strictly type-safe SQL query builder for TypeScript that catches query errors at compile time rather than runtime. Unlike ORMs that abstract away SQL, Kysely embraces raw SQL semantics while providing full autocompletion and type inference through a central Database interface. Every table becomes a property on this interface, and every column gets a precise TypeScript type — including nullable columns, auto-generated values, and JSON payloads. The Generated<> wrapper is Kysely's signature feature: it marks columns whose values are produced by the database (SERIAL sequences, DEFAULT expressions, trigger-populated fields), making them optional during INSERT but required in SELECT results. This converter parses your CREATE TABLE statements and produces the complete type scaffolding — per-table interfaces, the composite Database type, and optional Insertable/Updatable helper aliases — so you can start writing type-safe queries immediately without hand-mapping dozens of columns.

How to Use

1. Paste one or more CREATE TABLE statements into the SQL input area
2. Choose your database dialect — PostgreSQL, MySQL, or SQLite — to match type mappings correctly
3. Toggle the Generated&lt;&gt; option to wrap auto-increment and DEFAULT columns, and the Insertable/Updatable option to emit helper types for INSERT and UPDATE operations
4. Click "Generate Kysely Types" to produce the TypeScript interfaces
5. Copy the output into a types.ts file in your project and import the Database type when creating a Kysely instance

Tips & Best Practices

• Always enable Generated&lt;&gt; for SERIAL and DEFAULT columns — omitting it forces you to pass values the database would generate itself
• Use Insertable<T> as the parameter type in repository functions to accept only the fields the database expects during INSERT
• For JSON and JSONB columns, replace the generated unknown type with a specific interface (e.g., Generated<UserMeta>) for stronger typing
• When adding a new table, regenerate the entire file rather than appending — the Database interface must contain every table to preserve type safety

Frequently Asked Questions

Real-world Examples

CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  price DECIMAL(10,2) NOT NULL,
  metadata JSONB,
  created_at TIMESTAMP DEFAULT NOW()
);

import type { ColumnType, Generated, Insertable, Updatable } from 'kysely';

export interface ProductsTable {
  id: Generated<number>;
  name: string;
  price: number;
  metadata: unknown;
  created_at: Generated<Date>;
}

export interface Database {
  products: ProductsTable;
}

export type InsertableProducts = Insertable<Database['products']>;
export type UpdatableProducts = Updatable<Database['products']>;

CREATE TABLE posts (
  id SERIAL PRIMARY KEY,
  title VARCHAR(255) NOT NULL,
  body TEXT
);

CREATE TABLE comments (
  id SERIAL PRIMARY KEY,
  post_id INTEGER NOT NULL REFERENCES posts(id),
  author VARCHAR(100) NOT NULL,
  content TEXT NOT NULL,
  created_at TIMESTAMP DEFAULT NOW()
);

import type { ColumnType, Generated, Insertable, Updatable } from 'kysely';

export interface PostsTable {
  id: Generated<number>;
  title: string;
  body: string | null;
}

export interface CommentsTable {
  id: Generated<number>;
  post_id: number;
  author: string;
  content: string;
  created_at: Generated<Date>;
}

export interface Database {
  posts: PostsTable;
  comments: CommentsTable;
}

export type InsertablePosts = Insertable<Database['posts']>;
export type UpdatablePosts = Updatable<Database['posts']>;
export type InsertableComments = Insertable<Database['comments']>;
export type UpdatableComments = Updatable<Database['comments']>;

Related Tools