Newkastor 0.1.0: ten databases, one schema

The TypeScript ORM for every database.

Q: 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.

Q: 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.

Write your schema in plain TypeScript and the types are there as you type. No generate step, no binary engine. Nested includes in one query, readable migrations and a local studio on PostgreSQL, MySQL, SQLite, SQL Server, Oracle, MongoDB and four more.

Get started Open the playground

$ npm i kastor-orm

Start a projectInstall, create the client and run a first query on any of ten databases.
Move from PrismaOne command converts schema.prisma. Your data and migration history stay put.
Read the referenceEvery method, filter, error code and CLI command, with examples.

One schema and one API on the databases you already run

PostgreSQL
CockroachDB
MySQL
MariaDB
SQLite
libSQL / Turso
Cloudflare D1
SQL Server
Oracle
MongoDB

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.

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.1.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");

Migrate

Move from Prisma in one command

Point kastor at schema.prisma and get a TypeScript schema with the same table, column and constraint names. A baseline keeps the history Prisma already applied, so nothing in the database moves.

Same names, same tables. Models, enums, implicit join tables and relation fields carry over.
History kept. migrate baseline --from-prisma records every applied migration.
Any other ORM. db pull reads the live database into a schema file.

Prisma Drizzle TypeORM Sequelize Knex Mongoose Laravel Eloquent Django ORM Rails Active Record

All migration guides

Terminal

$ npx kastor import prisma

kastor / import prisma

  Prisma schema  prisma/schema.prisma
  Provider       postgresql (kastor-orm/postgres)

ok    Wrote src/db/schema.ts: 3 models, 1 join table, 1 enum, 4 relation fields.
ok    Every model, field and relation mapped exactly.

  +------------------------------------------------------------+
  | Next steps                                                 |
  | 1. Read src/db/schema.ts and point kastor.config.ts at it. |
  | 2. kastor migrate baseline --from-prisma prisma/migrations |
  |    records the database as it is now, without changing it. |
  | 3. kastor migrate dev should then say: Already in sync.    |
  +------------------------------------------------------------+

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.

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

Live playground

Type a schema. Watch the types and the SQL appear.

This is the real kastor compiler running in your browser. Edit the schema or the query: the result type is checked by the TypeScript compiler, and the SQL is compiled for every database side by side. Open Rows to run it on SQLite in this page.

Loading the compiler

// The inferred type appears here

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

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: {},
  })
})

Get started

Get started in 60 seconds

Pick your database. Three steps, and the schema from the playground 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 } })

From laptop to production

Build it, ship it, keep it healthy

The same schema file drives the client, the migrations and the studio, from the first table to the hundredth deploy.

BuildSchema, types and queriesWrite tables in TypeScript and query them with inferred results. The playground above is the real thing.db.users.findMany()MigrateReviewed SQL, every timemigrate dev writes the file, you commit it, migrate deploy applies it in CI before the new code ships.npx kastor migrate deployDeployServers, functions, edgeOne client per process, reused across hot reloads and invocations, with the pool or HTTP driver your host wants.export const db = kastor(...)InspectStudio and doctorBrowse and edit rows locally, read the diagram, and let kastor doctor check config, driver and connection.npx kastor doctor

Comparison

How kastor compares, by approach

There are many good ORMs. They make different trade-offs, so this table compares approaches rather than products. Check each tool's docs for its current details.

Aspect	kastor	Generated client ORMs	SQL first query builders	Decorator ORMs
Where the schema lives	TypeScript	A schema file in its own language	TypeScript	Classes with decorators
Types after a schema change	Inferred on the next keystroke	After running a generate command	Inferred	Declared by hand on classes
Query style	Objects: where, include, select	Objects: where, include, select	SQL shaped builder, plus a relational API in some tools	Repositories and a builder
Nested relations	One query per root call (JSON aggregation)	Varies by tool and version	Varies by API	Joins or extra queries
Migrations from the schema	Built in, rename detection asks first	Usually built in	Usually a separate kit	Usually built in
Same API on SQL and MongoDB	Yes	Varies by tool	Usually SQL only	Varies by tool
Runtime dependencies	Zero (bring your driver)	Varies	Small	Several

Coming from a specific tool? The migration guides map every concept and command, from Prisma and Drizzle to Laravel and Rails.

Guides

Long reads on the problems an ORM should solve

36 guides in English and more in Portuguese, from N+1 queries to running one data layer on every database.

TypeScript ORMChoosing a TypeScript ORM: what matters and how kastor worksWhat a TypeScript ORM is, what to look for before you pick one, and a full tour of kastor from schema to queries to migrations, plus when to skip an ORM.9 min read Type safe SQLType safe SQL in TypeScript, from inferred rows to raw queriesHow to get type safe SQL in TypeScript: inferred row types, select narrowing, InferSelect and InferInsert, and raw SQL with typed rows and bound parameters.10 min read Avoid N+1 queriesHow to avoid N+1 queries in a TypeScript appLearn to spot and avoid N+1 queries in TypeScript: query logging, nested includes in one query, relation counts, select, take inside includes and pagination.9 min read Migrations explainedDatabase migrations explained, from first table to productionDatabase migrations explained step by step: schema drift, the dev to deploy workflow, rename detection, safe destructive changes and running migrations in CI.10 min read Next.js and PostgresNext.js with PostgreSQL: a type-safe ORM setup for the App RouterSet up a Next.js Postgres ORM with the App Router: one reusable client, server components, server actions, serverless pools, env vars and migrations on deploy.10 min read Database seedingDatabase seeding in TypeScript that you can run twiceA practical guide to database seeding in TypeScript: typed seed files, idempotent upserts, bulk inserts, related rows, test factories and seeding in CI.9 min read

All 36 guides Guias em português

FAQ

Questions people ask

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

What is the best TypeScript ORM for multiple databases?

Pick one that infers types straight from a TypeScript schema and runs the same query API on every database you need. kastor supports 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 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.

One schema and one API on the databases you already run

Complete setups for 15 frameworks

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

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

Lay the first log.