NEW SurrealDB and Postgres are here — more drivers on the way.
Schema as code · any database

Your schema, in the Zod you already know.

Define your schema with s.* — a drop-in for Zod. Schemic generates your database's native DDL, validates at runtime, and runs your migrations.

View on GitHub

TypeScript-first Zod-compatible Standard Schema MIT

Your schema lives in four places.
None of them agree.

DDL
hand-written
Migrations
by hand
Types
drifts
Validation
bolted on

But you already describe your data in TypeScript.

// schema in, native ddl out

From s.* schema to generated native DDL .

Tests Soon
Studio Soon
Schemic
schema.ts TypeScript
1 import { s, defineTable } from "@schemic/<driver>";
2
3 // Pick a database — the shape stays the same, the import + output change
4 export const User = defineTable("user", {
5 id: s.string(),
6 name: s.string(),
7 email: s.string(),
8 createdAt: s.datetime(),
9 });
schema.ddl native DDL

Pick a database to see the generated output.

1 -- Pick a database to generate native DDL.
2
3
4
5
6
7
8

Define your tables and fields in TypeScript — the native DDL is generated for you.

// what you get

Everything you get with Schemic.

A drop-in s.* schema, generated DDL, a migration CLI, end-to-end types, the full define* vocabulary, and a live round-trip — all from one typed file.

Drop-in Zod API

A drop-in for z.* — refinements, defaults, coercion, and infer / input / output.

email: s.string(),
name: s.string().optional(),
createdAt: s.datetime(),

The API mirrors the z. you already know — plus $-methods that emit your database's DDL.

Adopt any database

Introspect a live database into typed schema files.

$ sc pull
// introspect a live DB → s.* schema

CLI toolbelt

sc status sc check sc doctor
sc rollback sc seed sc pull

End-to-end types

Infer row shapes straight from the schema.

type User = App<typeof User>
// Pick a database to infer row types.

Unsupported types are flagged in your editor — not at migration time.

Bring your own types

Store any class with a typed codec — app value in, wire type out.

// Pick a database to bring your own
// types with a typed codec.

Live round-trip

Diff against the running database.

~ sc diff --live
// Pick a database to diff a live DB.

// the cli

Migrations are first-class.

Write a migration from your schema, apply it, and check for drift against the live database — three commands, no DDL by hand.

schemic — cli
$sc generate add_users
~ select a database to see generated artifacts
$sc migrate
~ select a database to apply migrations
$sc diff --live
~ select a database to diff against a live DB

// if you know Zod, you already know this

Schema, DDL, and migrations — one file.

Go past tables and fields. Events, functions, and access rules all live in the same typed source — and generate real DDL.

access.ts → native DDL

Pick a database to see the generated output.

access.ts TypeScript
1 // Events, functions & access — one typed file.
2 // Pick a database to generate native DDL.
access.ddl native DDL
1 -- Select a database to generate native DDL.

// common questions

Questions, answered.

+

Is it really just Zod?

Yes — s.* is a drop-in for Zod's z.*: your fields are Zod schemas (and Standard Schema compatible). The validators you know — .email(), .min(), object composition — work app-side exactly as in Zod, and $-prefixed methods add the database DDL on top. If you know Zod, you're already at home.

+

Why not write the DDL by hand?

Hand-written DDL drifts from your types. Schemic keeps your schema, the generated DDL, and your TypeScript types as one source of truth — generated, never out of sync.

+

How do migrations run?

Three commands cover the whole loop: one writes a migration from the schema diff, one applies it, one checks for drift.

sc gen sc migrate sc diff --live
+

Which databases are supported?

SurrealDB and Postgres are available today; more databases are on the way through drivers. Each driver maps the full define* vocabulary — tables, fields, indexes, events, functions, and access — to that database's DDL. MIT licensed.

+

Can I adopt it on an existing database?

Yes. One command introspects the live database and generates the matching s.* schema files, so you start from the database you already have and migrate forward.

sc pull
+

Does it replace my database client?

No — it sits on top. You keep your database's official client for queries; Schemic owns the schema, the generated DDL, the migrations, and the row types.

+

Is it a query builder or an ORM?

Neither. Schemic is a schema + migrations toolkit. It owns the schema, the generated DDL, and the migrations; pair it with your database's query tools.

+

Can I drop to raw queries?

Always. Schemic owns the schema and migrations, not your queries — use your database's client directly, and compose raw expressions into defaults, events, permissions, and functions where a driver supports it.

// set up with ai

Let your agent wire it up.

Let your AI coding agent set up Schemic for you. Paste this prompt into Claude Code, Cursor, or any agent — it installs and configures the right driver for your database, brings your schema into TypeScript (new or existing), and prepares your first migration for you to review and run, explaining each step.

one prompt · full setup
Read the full guide

One schema. Zero drift.

Generate the DDL, run the migrations, keep your types — straight from the schema you already wrote.