Newkastor 0.2.0: ten databases, one schema

The TypeScript ORM for every database.

Write your schema in plain TypeScript and the types are there as you type. No generate step. One query API on SQL databases and MongoDB.

Try the tutorial Get started

$ npm i kastor-orm

Try it in five stepsA table, a relation, an include and a migration, right here in the browser.
Start a projectInstall, create the client and run a first query on your database.
Read the referenceEvery method, filter, error code and CLI command, with examples.

Pick your database. Every example on this page follows.

Live playground

Learn kastor in five small steps

The real kastor compiler runs in your browser. Each step asks for one small edit and checks it as you type: the result type comes from the TypeScript compiler, and the SQL follows the database you pick.

Step 1 of 5

Create a table

A table is a plain TypeScript value. Add a name column to users, for example name: t.string().nullable(), and watch the CREATE TABLE statement follow.

Your turn: make the edit, or press Show me.

Loading the compiler

// The inferred type appears here

kastor 0.2.0 compiled for the browser from the same source as the npm package.

The playground needs JavaScript. Every guide below shows the same API with highlighted code.

Schema and types

Write a schema, get types instantly

Tables and relations are ordinary TypeScript values. The compiler infers every result from them, so the types are already there on the next keystroke.

Plain TypeScript. No schema language, no extension, and your editor understands every line.
No generate step. Nothing to rerun after a change, nothing to forget in CI.
Shaped by the query. Includes add relations to the result, select narrows it.
Rename safely. Rename a column and every call site lights up in the editor.

src/db/schema.ts

import { table, t } from 'kastor-orm'

export const users = table('users', {
  id: t.id(),
  email: t.string(255).unique(),
  name: t.string().nullable(),
  role: t.enum(['user', 'admin']).default('user'),
  createdAt: t.datetime().defaultNow(),
})

export const posts = table('posts', {
  id: t.id(),
  title: t.string(200),
  published: t.boolean().default(false),
  authorId: t.int().references(() => users.id),
})

src/app.tsTypes up to date

import { db } from './db'

const user = await db.users.findUnique({
  where: { email: 'ada@acme.com' },
  include: { posts: true },
})

user?.posts[0].title

Inferred, not generated

const user: {
  id: number
  email: string
  name: string | null
  role: 'user' | 'admin'
  createdAt: Date
  posts: {
    id: number
    title: string
    published: boolean
    authorId: number
  }[]
} | null

Relations

Nested includes in one query

Ask for authors and their latest posts and kastor sends one statement, built for the database you run. Never one query per row.

src/feed.ts

const authors = await db.users.findMany({
  where: { email: { endsWith: '@acme.com' } },
  select: {
    name: true,
    posts: {
      where: { published: true },
      orderBy: { views: 'desc' },
      take: 3,
      select: { title: true, views: true },
    },
  },
})

SELECT "t0"."name" AS "name", (
  SELECT COALESCE(json_agg("s"."j" ORDER BY "s"."rn"), '[]'::json)
  FROM (
    SELECT json_build_object('title', "t1"."title", 'views', "t1"."views") AS "j", ROW_NUMBER() OVER (ORDER BY "t1"."views" DESC) AS "rn"
    FROM "posts" "t1"
    WHERE "t1"."authorId" = "t0"."id" AND ("t1"."published" = $1)
    ORDER BY "t1"."views" DESC
    LIMIT 3
  ) "s"
) AS "posts"
FROM "users" "t0"
WHERE "t0"."email" LIKE $2 ESCAPE '!'

SELECT `t0`.`name` AS `name`, (
  SELECT COALESCE(JSON_ARRAYAGG(CAST(`s`.`j` AS JSON)), JSON_ARRAY())
  FROM (
    SELECT JSON_OBJECT('title', `t1`.`title`, 'views', `t1`.`views`, '__kastor_rn', ROW_NUMBER() OVER (ORDER BY `t1`.`views` DESC)) AS `j`
    FROM `posts` `t1`
    WHERE `t1`.`authorId` = `t0`.`id` AND (`t1`.`published` = ?)
    ORDER BY `t1`.`views` DESC
    LIMIT 3
  ) `s`
) AS `posts`
FROM `users` `t0`
WHERE `t0`.`email` LIKE ? COLLATE utf8mb4_bin ESCAPE '!'

SELECT "t0"."name" AS "name", (
  SELECT json_group_array(json("s"."j"))
  FROM (
    SELECT json_object('title', "t1"."title", 'views', "t1"."views", '__kastor_rn', ROW_NUMBER() OVER (ORDER BY "t1"."views" DESC)) AS "j"
    FROM "posts" "t1"
    WHERE "t1"."authorId" = "t0"."id" AND ("t1"."published" = ?)
    ORDER BY "t1"."views" DESC
    LIMIT 3
  ) "s"
) AS "posts"
FROM "users" "t0"
WHERE substr("t0"."email", -length(?)) = ?

SELECT [t0].[name] AS [name], COALESCE((
  SELECT TOP (3) [t1].[title] AS [title], [t1].[views] AS [views]
  FROM [posts] [t1]
  WHERE [t1].[authorId] = [t0].[id] AND ([t1].[published] = @p1)
  ORDER BY [t1].[views] DESC
  FOR JSON PATH, INCLUDE_NULL_VALUES
), '[]') AS [posts]
FROM [users] [t0]
WHERE [t0].[email] COLLATE Latin1_General_100_BIN2 LIKE @p2 ESCAPE '!'

SELECT "t0"."name" AS "name", (
  SELECT JSON_ARRAYAGG("s"."j" FORMAT JSON ORDER BY "s"."rn" RETURNING CLOB)
  FROM (
    SELECT JSON_OBJECT('title' VALUE "t1"."title", 'views' VALUE "t1"."views" NULL ON NULL RETURNING CLOB) AS "j", ROW_NUMBER() OVER (ORDER BY "t1"."views" DESC) AS "rn"
    FROM "posts" "t1"
    WHERE "t1"."authorId" = "t0"."id" AND ("t1"."published" = :1)
    ORDER BY "t1"."views" DESC
    FETCH NEXT 3 ROWS ONLY
  ) "s"
) AS "posts"
FROM "users" "t0"
WHERE "t0"."email" LIKE :2 ESCAPE '!'

{
  "aggregate": "users",
  "pipeline": [
    {
      "$match": {
        "email": {
          "$regularExpression": {
            "pattern": "@acme\\.com\\z",
            "options": ""
          }
        }
      }
    },
    {
      "$lookup": {
        "from": "posts",
        "let": {
          "k0": "$_id"
        },
        "pipeline": [
          {
            "$match": {
              "$expr": {
                "$and": [
                  {
                    "$eq": [
                      "$authorId",
                      "$$k0"
                    ]
                  },
                  {
                    "$ne": [
                      "$$k0",
                      null
                    ]
                  }
                ]
              }
            }
          },
          {
            "$match": {
              "published": {
                "$eq": true
              }
            }
          },
          {
            "$sort": {
              "views": -1,
              "_id": 1
            }
          },
          {
            "$limit": 3
          },
          {
            "$project": {
              "_id": 0,
              "title": "$title",
              "views": "$views"
            }
          }
        ],
        "as": "__i0"
      }
    },
    {
      "$project": {
        "_id": 0,
        "name": "$name",
        "posts": "$__i0"
      }
    }
  ],
  "cursor": {}
}

One statement per call. Compiled at build time by the same code that ships on npm.

JSON aggregation on PostgreSQL, MySQL, MariaDB, SQLite, SQL Server and Oracle.

One pipeline with $lookup stages on MongoDB.

Every level takes its own where, orderBy, take and select.

Migrations

Migrations you can read

Change the schema, run one command. kastor diffs it against the live database, explains the plan in plain English and writes a SQL file you review and commit.

Careful by default. Warns before anything that can fail or lose data, and asks before it treats a rename as a drop.
Plain SQL files. One folder per migration, a header that says what changed, nothing hidden.
Built for CI. migrate deploy applies pending files, migrate status catches drift.
Existing database? db pull writes the schema from it, migrate baseline adopts it.
Coming from Prisma? kastor import prisma converts schema.prisma and keeps the history. See the migration guides.

src/db/schema.ts

export const posts = table('posts', {
  id: t.id(),
  title: t.string(200),
  slug: t.string(220).unique(),
  views: t.int().default(0),
  published: t.boolean().default(false),
})

Terminal

$ npx kastor migrate dev --name add_slug_and_views

kastor / migrate dev

  Config      kastor.config.ts
  Database    postgres
  Schema      src/db/schema.ts
  Migrations  kastor/migrations

ok    Loaded 2 tables from the schema
Changes  3 to add, 0 to change, 0 to drop

  + Add column posts.slug
  + Add column posts.views
  + Create unique index posts_slug_key on posts (slug)

  warn  Column posts.slug is required and has no default, so adding
        it fails if posts already has rows.
        Give it a default, make it nullable, or fill it in a second migration.

ok    Wrote kastor/migrations/20261014093012_add_slug_and_views/migration.sql
ok    Applied 20261014093012_add_slug_and_views 41 ms

migration.sql

-- Migration 20261014093012_add_slug_and_views
-- Written by kastor 0.2.0 for postgres.
--
-- Changes:
--   + Add column posts.slug
--   + Add column posts.views
--   + Create unique index posts_slug_key on posts (slug)

-- Add column posts.slug
ALTER TABLE "posts" ADD COLUMN "slug" varchar(220) NOT NULL;

-- Add column posts.views
ALTER TABLE "posts" ADD COLUMN "views" integer DEFAULT 0 NOT NULL;

-- Create unique index posts_slug_key on posts (slug)
CREATE UNIQUE INDEX "posts_slug_key" ON "posts" ("slug");

Studio

See your data. Edit it. Understand the shape.

Run npx kastor studio and a local web UI opens on your machine: browse every table, filter and search, edit rows, follow foreign keys and read the diagram of the whole database.

127.0.0.1:5555

Real screenshots of npx kastor studio on the playground schema with SQLite.

Runs on 127.0.0.1 behind a private session token, with your own config.
Filters, text search, paging and a read only mode for data you must not touch.
A diagram drawn from the live schema, downloadable as SVG.

Get started

Get started in 60 seconds

Three steps for the database you picked. The schema from the tutorial is all you need: put it in src/db/schema.ts.

1
Install kastor and the driver
Terminal
```
npm i kastor-orm pg
```

Create the client

Also Neon, Supabase and Vercel Postgres through pg compatible pools.

src/db/index.ts

import pg from 'pg'
import { kastor } from 'kastor-orm'
import { postgres } from 'kastor-orm/postgres'
import { schema, relations } from './schema'

const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL })

export const db = kastor({ adapter: postgres(pool), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm pg
```

Create the client

Serializable by default: kastor surfaces retry errors as SERIALIZATION_FAILURE.

src/db/index.ts

import pg from 'pg'
import { kastor } from 'kastor-orm'
import { cockroach } from 'kastor-orm/cockroach'
import { schema, relations } from './schema'

const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL })

export const db = kastor({ adapter: cockroach(pool), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm mysql2
```

Create the client

PlanetScale works through mysql2.

src/db/index.ts

import mysql2 from 'mysql2/promise'
import { kastor } from 'kastor-orm'
import { mysql } from 'kastor-orm/mysql'
import { schema, relations } from './schema'

const pool = mysql2.createPool(process.env.DATABASE_URL!)

export const db = kastor({ adapter: mysql(pool), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm mariadb
```

Create the client

Works with the mariadb driver, or with mysql2 against a MariaDB server.

src/db/index.ts

import * as mariadbDriver from 'mariadb'
import { kastor } from 'kastor-orm'
import { mariadb } from 'kastor-orm/mariadb'
import { schema, relations } from './schema'

const pool = mariadbDriver.createPool(process.env.DATABASE_URL!)

export const db = kastor({ adapter: mariadb(pool), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm better-sqlite3
```

Create the client

Also node:sqlite and bun:sqlite with the same adapter.

src/db/index.ts

import Database from 'better-sqlite3'
import { kastor } from 'kastor-orm'
import { sqlite } from 'kastor-orm/sqlite'
import { schema, relations } from './schema'

export const db = kastor({ adapter: sqlite(new Database('app.db')), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm @libsql/client
```

Create the client

Turso in the cloud, file: URLs and embedded replicas locally.

src/db/index.ts

import { createClient } from '@libsql/client'
import { kastor } from 'kastor-orm'
import { libsql } from 'kastor-orm/libsql'
import { schema, relations } from './schema'

const client = createClient({ url: process.env.TURSO_DATABASE_URL!, authToken: process.env.TURSO_AUTH_TOKEN })

export const db = kastor({ adapter: libsql(client), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm
```

Create the client

D1 has no interactive transactions: the array form of $transaction runs as one D1 batch, the callback form is refused by default.

src/worker.ts

import { kastor } from 'kastor-orm'
import { d1 } from 'kastor-orm/d1'
import { schema, relations } from './schema'

export default {
  async fetch(request: Request, env: { DB: D1Database }) {
    const db = kastor({ adapter: d1(env.DB), schema, relations })
    return Response.json(await db.users.findMany({ take: 10 }))
  },
}

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm mssql
```

Create the client

Azure SQL works with the same driver.

src/db/index.ts

import sql from 'mssql'
import { kastor } from 'kastor-orm'
import { mssql } from 'kastor-orm/mssql'
import { schema, relations } from './schema'

const pool = await new sql.ConnectionPool(process.env.DATABASE_URL!).connect()

export const db = kastor({ adapter: mssql(pool), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm oracledb
```

Create the client

node-oracledb thin mode: no Instant Client to install.

src/db/index.ts

import oracledb from 'oracledb'
import { kastor } from 'kastor-orm'
import { oracle } from 'kastor-orm/oracle'
import { schema, relations } from './schema'

const pool = await oracledb.createPool({ user: 'app', password: process.env.ORACLE_PASSWORD, connectString: 'localhost:1521/FREEPDB1' })

export const db = kastor({ adapter: oracle(pool), schema, relations })

Create the tables and query

Terminal

npx kastor migrate dev --name init

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

1
Install kastor and the driver
Terminal
```
npm i kastor-orm mongodb
```

Create the client

Keys are ObjectIds exposed as strings by default; mongodb(db, { ids: 'int' }) keeps numbers like SQL. Transactions need a replica set (a single node one works locally).

src/db/index.ts

import { MongoClient } from 'mongodb'
import { kastor } from 'kastor-orm'
import { mongodb } from 'kastor-orm/mongodb'
import { schema, relations } from './schema'

const client = await new MongoClient(process.env.MONGO_URL!).connect()

export const db = kastor({ adapter: mongodb(client.db('app')), schema, relations })

Create the tables and query

Terminal

npx kastor db push

src/app.ts

const users = await db.users.findMany({ include: { posts: true } })

Database support

One schema, ten databases

Every adapter takes the driver you already use. The same queries compile to each dialect: JSON aggregation for includes, the native way to return written rows, the native upsert.

Database	Import	Driver	Includes	Written rows	Upsert	Paging	Transactions	Migrations
PostgreSQL	`kastor-orm/postgres`	`pg`	json_agg + json_build_object	RETURNING	ON CONFLICT	LIMIT / OFFSET	yes	yes
CockroachDB	`kastor-orm/cockroach`	`pg`	json_agg + json_build_object	RETURNING	ON CONFLICT	LIMIT / OFFSET	yes	yes
MySQL	`kastor-orm/mysql`	`mysql2`	JSON_ARRAYAGG + JSON_OBJECT	Re-select by key	ON DUPLICATE KEY UPDATE	LIMIT / OFFSET	yes	yes
MariaDB	`kastor-orm/mariadb`	`mariadb`	JSON_ARRAYAGG + JSON_OBJECT	Re-select by key	ON DUPLICATE KEY UPDATE	LIMIT / OFFSET	yes	yes
SQLite	`kastor-orm/sqlite`	`better-sqlite3`	json_group_array + json_object	RETURNING	ON CONFLICT	LIMIT / OFFSET	yes	yes
libSQL / Turso	`kastor-orm/libsql`	`@libsql/client`	json_group_array + json_object	RETURNING	ON CONFLICT	LIMIT / OFFSET	yes	yes
Cloudflare D1	`kastor-orm/d1`	`D1 binding`	json_group_array + json_object	RETURNING	ON CONFLICT	LIMIT / OFFSET	Batch	yes
SQL Server	`kastor-orm/mssql`	`mssql`	FOR JSON PATH	OUTPUT	MERGE	TOP / OFFSET FETCH	yes	yes
Oracle	`kastor-orm/oracle`	`oracledb`	JSON_ARRAYAGG + JSON_OBJECT	RETURNING INTO	MERGE	OFFSET / FETCH NEXT	yes	yes
MongoDB	`kastor-orm/mongodb`	`mongodb`	$lookup pipeline	Native documents	findAndModify, then insert	$skip / $limit	yes	yes

The adapters share one conformance suite, run against real databases in CI. Serverless Postgres (Neon, Supabase, Vercel Postgres) runs through pg compatible pools and PlanetScale through mysql2.

Everything else

Everything a data layer needs

12 more details. Each one is real code that runs on every supported database.

Schema in plain TypeScript

Tables, columns, indexes and relations are ordinary TypeScript values. No schema language to learn, no extension to install, and your editor already understands every line.

src/db/schema.ts

import { table, t, index } from 'kastor-orm'

export const users = table('users', {
  id: t.id(),
  email: t.string(255).unique(),
  name: t.string().nullable(),
  role: t.enum(['user', 'admin']).default('user'),
  createdAt: t.datetime().defaultNow(),
})

export const posts = table('posts', {
  id: t.uuid().primaryKey().defaultRandom(),
  title: t.string(200),
  published: t.boolean().default(false),
  authorId: t.int().references(() => users.id, { onDelete: 'cascade' }),
}, { indexes: (p) => [index(p.authorId)] })

Types inferred as you type

There is no generate step. Change a column and every query that touches it is checked again on the next keystroke, in the editor and in CI, with nothing to regenerate.

src/types.ts

import type { InferSelect, InferInsert } from 'kastor-orm'
import { users } from './db/schema'

type User = InferSelect<typeof users>
// { id: number; email: string; name: string | null;
//   role: 'user' | 'admin'; createdAt: Date }

type NewUser = InferInsert<typeof users>
// { email: string; name?: string | null; role?: 'user' | 'admin'; ... }

Friendly, familiar queries

findMany, findUnique, create, update, upsert, count, aggregate and groupBy with where, select, orderBy, take, skip, cursor and distinct. Filters read like the sentence you would say out loud.

src/routes/users.ts

const admins = await db.users.findMany({
  where: {
    role: 'admin',
    email: { endsWith: '@acme.com', mode: 'insensitive' },
    OR: [{ name: { startsWith: 'A' } }, { name: null }],
  },
  orderBy: { createdAt: 'desc' },
  take: 20,
})

Nested includes in one query

Relations load with JSON aggregation inside a single statement on every SQL database, and as $lookup stages of one pipeline on MongoDB. Never one query per row.

src/routes/feed.ts

const feed = await db.users.findMany({
  include: {
    posts: {
      where: { published: true },
      orderBy: { title: 'asc' },
      take: 3,
      include: { tags: true },
    },
    _count: { select: { posts: true } },
  },
})

Nested writes

Create a row with its children, or connect it to existing ones, in one call. kastor splits the work into single table writes inside one transaction.

src/signup.ts

const user = await db.users.create({
  data: {
    email: 'ada@example.com',
    name: 'Ada',
    posts: {
      create: [{ title: 'Hello, rows' }, { title: 'Logs all the way down' }],
    },
  },
  include: { posts: true },
})

Transactions, both ways

An interactive callback when one step depends on the last, or an array of queries that run together. Errors roll everything back.

src/transfer.ts

await db.$transaction(async (tx) => {
  const order = await tx.orders.create({ data: { userId, total } })
  await tx.stock.update({ where: { sku }, data: { count: { decrement: 1 } } })
  return order
})

await db.$transaction([
  db.sessions.deleteMany({ where: { userId } }),
  db.users.delete({ where: { id: userId } }),
])

Typed raw SQL

When a query is easier in SQL, write SQL. Template values become parameters, never string concatenation, and the row type is yours to declare.

src/reports.ts

const since = new Date('2026-01-01')

const rows = await db.$sql<{ day: string; signups: number }>`
  select date(created_at) as day, count(*) as signups
  from users
  where created_at >= ${since}
  group by day
  order by day
`

Errors that tell you the fix

Driver errors become a KastorError with a stable code, a plain English message and a hint, the same on every database.

src/signup.ts

import { isKastorError } from 'kastor-orm'

try {
  await db.users.create({ data: { email } })
} catch (e) {
  if (isKastorError(e) && e.code === 'UNIQUE_VIOLATION') {
    console.log(e.message) // what went wrong, in plain English
    console.log(e.hint)    // how to fix it
  }
}

Automatic migrations

kastor diffs your TypeScript schema against the live database and writes a readable SQL file you can review and edit. A renamed column is a question, never a silent drop.

Terminal

npx kastor migrate dev --name add_posts
npx kastor migrate status
npx kastor migrate deploy

Existing database? Pull it

Point kastor at a database you already have and it writes the TypeScript schema for you, relations included, so you can start querying in minutes.

Terminal

npx kastor db pull

Soft delete and cursor pages

Mark a table with softDelete and deletes set a timestamp instead, filtered out everywhere, includes too. findPage returns opaque cursors for stable infinite scroll.

src/db/schema.ts

export const notes = table('notes', {
  id: t.id(),
  body: t.text(),
  deletedAt: t.datetime().nullable(),
}, { softDelete: 'deletedAt' })

await db.notes.delete({ where: { id: 1 } })   // sets deletedAt
await db.notes.restore({ where: { id: 1 } })  // brings it back

const page = await db.notes.findPage({ first: 20, orderBy: { id: 'desc' } })
const next = await db.notes.findPage({ first: 20, orderBy: { id: 'desc' }, after: page.pageInfo.endCursor })

Seeds and test factories

A typed seed file for every environment, and factories that build valid, unique rows for tests in one line each.

src/db/seed.ts and factories

import { defineSeed, factory } from 'kastor-orm'
import { db as client, type Db } from './index'

// tests: one line per row, unique by sequence
export const userFactory = factory(client.users, ({ seq }) => ({
  email: `user${seq}@example.com`,
  name: `User ${seq}`,
}))
const ada = await userFactory.create({ name: 'Ada' })

// npx kastor db seed
export default defineSeed<Db>(async (db) => {
  await db.users.upsert({
    where: { email: 'admin@example.com' },
    create: { email: 'admin@example.com', role: 'admin' },
    update: {},
  })
})

Runtimes

Runs everywhere your code runs

The core has no Node only imports and ships no drivers, so kastor goes wherever your driver goes: servers, serverless functions and the edge.

Node.js18, 20 and 22 Bunbun:sqlite built in Denonpm: specifiers Cloudflare WorkersD1, Turso, Neon VercelNode and edge functions NetlifyFunctions and edge

Complete setups for 15 frameworks

Next.jsApp Router, server components, server actions NuxtNitro server routes SvelteKitload functions and form actions Remix and React Routerloaders and actions in framework mode Astroon-demand pages and endpoints Expressone client per process Fastifydecorate the instance NestJSa global module and a provider HonoNode, Bun, Deno and Workers AdonisJSa service module next to or instead of Lucid Bunbun:sqlite, no driver to install Denonpm specifiers Cloudflare WorkersD1, or Postgres through a pooler ElectronSQLite in the main process, typed IPC AWS Lambdareuse across warm invocations

All framework setups Framework guides

FAQ

Questions people ask

Still curious? Open an issue on GitHub and Kas will take a look.

Which databases does kastor support?

PostgreSQL, CockroachDB, MySQL, MariaDB, SQLite (better-sqlite3, node:sqlite, bun:sqlite), libSQL and Turso, Cloudflare D1, SQL Server, Oracle and MongoDB, with one schema and one query API.

Does kastor need a generate step or a binary engine?

No. Types are inferred from the schema by the TypeScript compiler as you type, and queries are compiled to SQL in plain JavaScript. There is nothing to regenerate in CI and nothing native to download.

How does kastor avoid N+1 queries?

Nested includes load in one statement per root call: JSON aggregation on every SQL database and a single aggregation pipeline with $lookup stages on MongoDB. Never one query per row. See the N+1 guide.

How do I migrate from Prisma to kastor?

Run npx kastor import prisma to turn schema.prisma into a TypeScript schema, then npx kastor migrate baseline --from-prisma prisma/migrations so the migrations Prisma already applied stay recorded. Your data never moves. The Prisma migration guide maps every client call, and the migration hub covers Drizzle, TypeORM, Sequelize, Knex, Mongoose, Laravel, Django and Rails.

Can I use kastor with an existing database?

Yes. Run npx kastor db pull to introspect the live database into a TypeScript schema file, relations included, then query it right away. Migrations can take over from there when you are ready.

Which drivers does kastor install?

None. kastor ships no database drivers: you install the one you want (pg, mysql2, better-sqlite3, mssql, oracledb, mongodb and so on) and pass its instance to the adapter. Drivers are optional peer dependencies.

Does kastor work on serverless and edge runtimes?

Yes, wherever the driver works: Cloudflare Workers with D1, Turso over HTTP, Neon, Supabase and Vercel Postgres through pg compatible pools, Bun with bun:sqlite and Deno with npm specifiers. The core has no Node only imports.

Is kastor free?

Yes. kastor is open source under the MIT license, including the CLI, migrations and the studio.

Lay the first log.

One install, one schema file, and your database is typed end to end.

Get started

$ npm i kastor-orm

The TypeScript ORM for every database.

Pick your database. Every example on this page follows.

Create a table

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Install kastor and the driver

Create the client

Create the tables and query

Schema in plain TypeScript

Types inferred as you type

Friendly, familiar queries

Nested includes in one query

Nested writes

Transactions, both ways

Typed raw SQL

Errors that tell you the fix

Automatic migrations

Existing database? Pull it

Soft delete and cursor pages

Seeds and test factories

Complete setups for 15 frameworks

Lay the first log.