SchemaForge

Bidirectional ORM schema converter — convert between SQL DDL, Prisma, Drizzle, TypeORM, Django, SQLAlchemy, Alembic migrations, JSON Schema, GraphQL SDL, EF Core (C#), and Scala case classes. 11 formats, 100 conversion directions.

Why SchemaForge?

Convert any schema to any format, verify equivalence with the diff command, generate Alembic migrations, produce JSON Schema definitions, create GraphQL SDL types, convert Entity Framework (C#) entities, generate Scala case classes, and batch-process entire directories. Whether you're migrating from Prisma to Drizzle, sharing a schema with a Django backend, exposing your data model as GraphQL, translating C# entities to Scala, or working with the SchemaForge VS Code extension for live preview — SchemaForge handles it.

Quick Start

# Install (package publishing pending — install from source)
pip install git+https://github.com/Coding-Dev-Tools/schemaforge.git
# Convert Prisma → Drizzle
schemaforge convert --from prisma --to drizzle --input schema.prisma
# Generate GraphQL from SQL
schemaforge convert --from sql --to graphql --input schema.sql --output schema.graphql
# Generate JSON Schema from Prisma
schemaforge convert --from prisma --to json_schema --input schema.prisma --output schema.json
# Generate Alembic migration from SQL
schemaforge convert --from sql --to alembic --input schema.sql --output migrations/initial.py
# Apply custom type mappings
schemaforge convert --from sql --to prisma --input schema.sql --type-map my-types.yaml
# Diff two schemas
schemaforge diff schema-v1.prisma schema-v2.prisma
# Check all schemas in a directory are consistent
schemaforge check --dir ./schemas/

Installation

# Install from source (recommended — PyPI publishing pending)
pip install git+https://github.com/Coding-Dev-Tools/schemaforge.git

Requires Python 3.10+.

Commands

`schemaforge convert`

Convert a schema from one format to another. Every format converts to and from every other format, except Alembic which is generator-only (a target, not a source) — 100 direction pairs.

# Format-specific examples
schemaforge convert --from sql --to prisma --input schema.sql
schemaforge convert --from prisma --to drizzle --input schema.prisma
schemaforge convert --from drizzle --to sql --input schema.drizzle.ts
schemaforge convert --from typeorm --to django --input entities/
schemaforge convert --from django --to sqlalchemy --input models.py
schemaforge convert --from sqlalchemy --to prisma --input models.py
# Alembic migration generation
schemaforge convert --from sql --to alembic --input schema.sql --output migrations/initial.py
schemaforge convert --from prisma --to alembic --input schema.prisma --output migrations/
# JSON Schema
schemaforge convert --from sql --to json_schema --input schema.sql --output schema.json
schemaforge convert --from json_schema --to prisma --input schema.json
# GraphQL SDL
schemaforge convert --from sql --to graphql --input schema.sql --output schema.graphql
schemaforge convert --from graphql --to prisma --input schema.graphql
# Custom type mapping
schemaforge convert --from sql --to prisma --input schema.sql --type-map my-types.yaml
# Dir mode (check all files are consistent)
schemaforge check --dir ./schemas/ --canonical prisma

`schemaforge diff`

Compare two schema files in the same format and see line-level differences.

schemaforge diff schema-v1.prisma schema-v2.prisma
schemaforge diff schema.sql schema-updated.sql --format sql
schemaforge diff fixtures/sample.sql fixtures/sample.prisma --format prisma

Detects added, removed, and modified tables, columns, indexes, and constraints.

Supported Formats

Format	Import	Export	Roundtrip
SQL DDL	✓	✓	✓
Prisma schema	✓	✓	✓
Drizzle schema	✓	✓	✓
TypeORM entities	✓	✓	✓
Django models	✓	✓	✓
SQLAlchemy models	✓	✓	✓
Alembic migrations	—	✓	—
JSON Schema	✓	✓	✓
GraphQL SDL	✓	✓	✓
EF Core (C#)	✓	✓	✓
Scala case class	✓	✓	✓

Alembic is generator-only: you can create migration scripts from any format, but parsing existing migrations back to IR is not yet supported.

Limitations

Foreign keys & relationships — the shared IR does not yet model foreign-key constraints or ORM relations, so FOREIGN KEY / REFERENCES clauses, Prisma/TypeORM relation fields, and Django ForeignKey fields are dropped during conversion rather than roundtripped. Tables, columns, types, defaults, indexes, unique constraints, and enums are preserved. FK support is on the roadmap.
Alembic is generator-only (see above) — you can generate migrations from any format but not parse them back.

Format Identifiers for `--from` / `--to`

CLI identifier	Format
`sql`	SQL DDL
`prisma`	Prisma schema
`drizzle`	Drizzle ORM schema
`typeorm`	TypeORM entities
`django`	Django models
`sqlalchemy`	SQLAlchemy declarative models
`alembic`	Alembic migration scripts
`json_schema`	JSON Schema (draft 2020-12)
`graphql`	GraphQL SDL
`ef`	Entity Framework Core (C#)
`scala`	Scala case classes (Doobie/Quill/Slick)

How It Works

SchemaForge uses a shared Internal Representation (IR) — all formats convert to and from this common schema definition. This architecture guarantees:

High-fidelity roundtripping: sql → prisma → sql reproduces tables, columns, types, defaults, indexes, unique constraints, and enums. Foreign-key/relationship constraints are not yet modeled in the IR and are dropped (see Limitations).
Bidirectional conversion: every format can convert to every other format, except Alembic, which is generator-only (a target, not a source)
Extensibility: adding a new format requires only a parser and a generator — no pairwise converters

| SQL DDL ───┐
| Prisma ────┤
| Drizzle ───┤
| TypeORM ───┤
| Django ────┤
| SQLAlchemy ───┤
| Alembic ────┤
| JSON Schema ──┤
| GraphQL ────┤
| EF Core ─────┤
| Scala ─────┤

Each parser reads format-specific syntax and builds a schema IR. Each generator takes the same IR and produces format-native output. The fn: prefix convention preserves SQL function defaults (CURRENT_TIMESTAMP, NOW(), gen_random_uuid()) across format boundaries.

Custom Type Mappings (v1.1.0+)

Override default type mappings with YAML or JSON configuration files.

# type-overrides.yamloverrides:
prisma:
STRING: "String @db.VarChar({length})"UUID: "String @db.Uuid"sql:
STRING: "TEXT"DATETIME: "TIMESTAMP WITH TIME ZONE"

Template variables available: {length}, {precision}, {scale}, {values}.

# Apply overrides during conversion
schemaforge convert --from sql --to prisma --input schema.sql --type-map type-overrides.yaml

Type Mapping

SchemaForge maps types intelligently between ORM systems. The core ColumnType enum represents all supported data types, and each format maps them to their native equivalents.

ColumnType	SQL DDL	Prisma	Drizzle	TypeORM	Django	SQLAlchemy	Alembic	JSON Schema	GraphQL
STRING	VARCHAR(n) / TEXT	String @db.VarChar(n)	varchar(n)	varchar	CharField(max_length=n)	String(n)	sa.String(n)	type: string	String
INTEGER	INTEGER	Int	integer	integer	IntegerField	Integer	sa.Integer	type: integer	Int
FLOAT	FLOAT	Float	real	float	FloatField	Float	sa.Float	type: number	Float
BOOLEAN	BOOLEAN	Boolean	boolean	boolean	BooleanField	Boolean	sa.Boolean	type: boolean	Boolean
DATETIME	TIMESTAMP	DateTime	timestamp	timestamp	DateTimeField	DateTime	sa.DateTime	format: date-time	DateTime
DATE	DATE	DateTime	date	date	DateField	Date	sa.Date	format: date	Date
TIME	TIME	DateTime	time	time	TimeField	Time	sa.Time	format: time	Time
TEXT	TEXT	String	text	text	TextField	Text	sa.Text	type: string	String
BLOB	BLOB	Bytes	blob	blob	BinaryField	LargeBinary	sa.LargeBinary	format: binary	String
JSON	JSON	Json	json	json	JSONField	JSON	sa.JSON	type: object	JSON
UUID	UUID	String	uuid	uuid	UUIDField	Uuid	sa.Uuid	format: uuid	ID
ENUM	ENUM('a','b')	(via enum)	pgEnum	enum	CharField	Enum	sa.Enum	(enum)	enum
DECIMAL	DECIMAL(p,s)	Decimal	numeric(p,s)	decimal(p,s)	DecimalField	Numeric(p,s)	sa.Numeric(p,s)	type: number	Float
CUSTOM	(passthrough)	(passthrough)	(passthrough)	(passthrough)	(passthrough)	(passthrough)	(passthrough)	(passthrough)	(passthrough)

Function defaults (CURRENT_TIMESTAMP, NOW(), gen_random_uuid(), etc.) are preserved across conversions using a fn: prefix convention.

Demo Fixtures

Try SchemaForge immediately with our example blog schema. The fixtures/ directory contains an equivalent schema (users, posts, categories with enums and various data types) in all 11 formats:

# List all fixtures
ls fixtures/
# Convert SQL → Prisma
schemaforge convert --from sql --to prisma --input fixtures/sample.sql
# Convert Prisma → Django
schemaforge convert --from prisma --to django --input fixtures/sample.prisma
# Convert SQL → GraphQL
schemaforge convert --from sql --to graphql --input fixtures/sample.sql
# Convert SQL → JSON Schema
schemaforge convert --from sql --to json_schema --input fixtures/sample.sql
# Convert Prisma → Alembic migration
schemaforge convert --from prisma --to alembic --input fixtures/sample.prisma --output migrations/
# Custom type mapping demo
schemaforge convert --from sql --to prisma --input fixtures/sample.sql \
--type-map fixtures/sample-type-overrides.yaml
# Batch convert all fixtures from SQL
schemaforge check --dir fixtures/
# Diff two format outputs
schemaforge diff fixtures/sample.sql fixtures/sample.prisma --format prisma

Each fixture demonstrates the same blog schema so you can compare ORM syntax side-by-side and verify roundtrip consistency.

Features

Bidirectional conversion — every format converts to and from every other format (Alembic is generator-only: a target, not a source)
High-fidelity roundtripping — sql → prisma → sql reproduces tables, columns, types, defaults, indexes, and enums (foreign keys are not yet preserved — see Limitations)
Custom type mappings — YAML/JSON config files to override any type mapping with template variables
VS Code extension — live preview, schema diff, and one-click conversion from VS Code
Alembic migration generation — create database migration scripts from any schema format
JSON Schema — import/export schema definitions as JSON Schema (draft 2020-12)
GraphQL SDL — generate or consume GraphQL type definitions with enums, directives, and scalars
EF Core (C#) support — import/export Entity Framework entity classes with data annotations
Scala case class support — generate case classes targeting Doobie/Quill/Slick
Diff mode — compare two schemas in the same format with line-level differences
Batch mode — convert entire directories of schema files with one command
Intelligent type mapping — types map correctly across all 11 formats
Function default preservation — CURRENT_TIMESTAMP, NOW(), gen_random_uuid() survive roundtrips
MySQL support — ENGINE=InnoDB, AUTO_INCREMENT, DEFAULT CHARSET, COMMENT table options
Inline ENUM — ENUM('small', 'medium', 'large') column types parsed and roundtripped
Index & constraint preservation — indexes and unique constraints maintained across all conversions (foreign-key/relationship constraints are not yet modeled — see Limitations)
Custom type handling — dialect-specific types (JSONB, etc.) pass through via CUSTOM type

MCP Server

SchemaForge includes an MCP (Model Context Protocol) server that exposes all schema operations as tools for AI agents. This allows AI coding assistants like Claude Code, Cursor, and others to convert, diff, and check schemas directly.

# Install with MCP support
pip install "schemaforge[mcp] @ git+https://github.com/Coding-Dev-Tools/schemaforge.git"# Start the server (stdio mode — default for AI clients)
schemaforge mcp
# Start as SSE HTTP server
schemaforge mcp --sse --port 8000

Available Tools

Tool	Description
`convert`	Convert a schema between any two of the 11 formats
`diff`	Compare two schemas and show differences
`check`	Verify schema consistency across a directory
`formats`	List all supported formats with descriptions
`detect_format`	Identify format from filename

Configuration for AI Clients

Claude Desktop (claude_desktop_config.json):

{
"mcpServers": {
"schemaforge": {
"command": "schemaforge",
"args": ["mcp"]
}
}
}

Cursor: Add to .cursor/mcp.json:

{
"mcpServers": {
"schemaforge": {
"command": "schemaforge",
"args": ["mcp"]
}
}
}

VS Code Extension

The SchemaForge VS Code extension provides live schema preview, quick conversion, and schema diffing directly from your editor.

Features

Live Preview — opens a side panel showing your active schema file converted to all other formats (tabbed interface for quick comparison)
Quick Convert — Ctrl+Alt+S / Cmd+Alt+S to convert the active editor's schema to your configured default target format
Format Detection — Ctrl+Alt+D / Cmd+Alt+D to detect and display the format of the active schema file
Diff Two Schemas — select two schema files to diff them side-by-side in VS Code's native diff editor
Right-Click Conversion — right-click any schema file in the explorer to convert it
Custom Editor — open .schemaforge files for a rich conversion preview
Auto-Refresh — preview panel updates when you save a schema file or switch tabs

Installation

Install SchemaForge: pip install git+https://github.com/Coding-Dev-Tools/schemaforge.git
Install the extension from the VS Code Marketplace
Open a .sql, .prisma, .graphql, .cs, or .scala file
Run SchemaForge: Show Preview from the command palette

Configuration

Setting	Default	Description
`schemaforge.cliPath`	`schemaforge`	Path to the schemaforge CLI executable
`schemaforge.defaultTargetFormat`	`prisma`	Default target format for quick conversions
`schemaforge.livePreview.enabled`	`true`	Enable live preview panel when editing schema files

Development

git clone https://github.com/Coding-Dev-Tools/vscode-schemaforge.git
cd vscode-schemaforge
npm install
npm run compile
# Press F5 in VS Code to launch extension host

Roadmap

Version	Features
v0.1.0	SQL DDL ↔ Prisma bidirectional conversion
v0.2.0	Drizzle schema support
v0.3.0	TypeORM entities support
v0.4.0	Django models support
v0.5.0	SQLAlchemy support, diff mode, batch mode, custom type mappings
v0.6.0	SQL parser edge cases (TEMPORARY TABLE, backtick quoting, fn: defaults)
v0.7.0	MySQL table options (ENGINE, CHARSET), inline ENUM('a','b','c')
v0.8.0	Alembic migration generation (7th format)
v0.9.0	Shared generator base module, refactored fn: default handling
v1.0.0	Stable release — comprehensive docs, CLI polish
v1.1.0	Custom type mapping configuration (YAML/JSON overrides)
v1.2.0	JSON Schema support (8th format)
v1.3.0	GraphQL SDL support (9th format)
v1.4.0	Schema consistency check, CI/CD workflow, MCP server
v1.5.0	Entity Framework Core (C#) support (10th format)
v1.6.0	Scala case class support (11th format)
v1.7.0	VS Code extension — live preview, diff, quick convert

Planned

VS Code extension: in-editor syntax highlighting for all 11 schema formats
Live schema watch mode for automatic re-conversion on file change
Mermaid/ERD diagram generation from schema IR
Terraform/OpenTofu provider for schema drift detection
Web dashboard with schema diff history

Pricing

SchemaForge is one of 11 tools in the Revenue Holdings suite. One license covers all CLI tools.

Plan	Price	Best For
Free	$0	Individual devs, OSS — CLI only, rate-limited
SchemaForge Individual	$15/mo ($12 billed annually)	Professional devs — unlimited conversions, batch mode
Suite (all 11 tools)	$49/mo ($39 billed annually)	Full Revenue Holdings toolkit — 40% savings
Team	$79/mo ($63 billed annually)	Up to 5 devs — shared schemas, team dashboard, alerts
Enterprise	Custom	SSO, RBAC, compliance reports, dedicated support

🔹 No lock-in: CLI works fully offline on the free tier — no telemetry, no phone-home. 🔹 Annual billing: Save 20%.

Per-Tier Features

Feature	Free	Individual	Suite	Team	Enterprise
	CLI: convert, diff	✓	✓	✓	✓
	All 11 format directions	—	✓	✓	✓
	Alembic migration generation	—	✓	✓	✓
	JSON Schema import/export	—	✓	✓	✓
	GraphQL SDL import/export	—	✓	✓	✓
	MCP server (AI agent tools)	✓	✓	✓	✓
	Custom type mappings	—	✓	✓	✓
	Batch directory conversion	—	✓	✓	✓
	Team shared type mappings	—	—	—	✓
	Dashboard & analytics	—	—	—	✓
	Compliance reports	—	—	—	—
	RBAC / SSO / SAML / OIDC	—	—	—	—
Priority support	Community	24h	24h	8h	Dedicated

Development

# Clone and install in dev mode
git clone https://github.com/Coding-Dev-Tools/schemaforge.git
cd schemaforge
pip install -e ".[dev]"# Run tests
pytest tests/ -v
# Run tests with coverage
pytest tests/ --cov=schemaforge

Contributing

PRs welcome! New format parsers/generators, bug fixes, and documentation improvements are all appreciated.

Fork the repo
Create a feature branch (git checkout -b feat/awesome-format)
Add your parser and generator in src/schemaforge/parsers/ and src/schemaforge/generators/
Register in src/schemaforge/convert.py
Add tests in tests/
Run the full test suite (pytest tests/ -v)
Submit a PR

License

MIT — see LICENSE

_{Part of Revenue Holdings — a suite of 11 developer CLI tools built by autonomous AI agents. Also check out the SchemaForge VS Code extension, ConfigDrift (config drift detection), DataMorph (data format conversion), DeadCode (dead code cleanup), DeployDiff (infrastructure diffs), Envault (env sync), APIAuth (API key management), APIGhost (mock API server), json2sql (JSON → SQL), API Contract Guardian (breaking change detection), and click-to-mcp (CLI → MCP server).}

Name		Name	Last commit message	Last commit date
.github		.github
fixtures		fixtures
scripts		scripts
src/schemaforge		src/schemaforge
tests		tests
.gitattributes		.gitattributes
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
cli.js		cli.js
eslint.config.mjs		eslint.config.mjs
package.json		package.json
pyproject.toml		pyproject.toml

Navigation Menu

Repository files navigation

SchemaForge

Quick Start

Installation

Commands

`schemaforge convert`

`schemaforge diff`

Supported Formats

Limitations

Format Identifiers for `--from` / `--to`

How It Works

Custom Type Mappings (v1.1.0+)

Type Mapping

Demo Fixtures

Features

MCP Server

Available Tools

Configuration for AI Clients

VS Code Extension

Features

Installation

Configuration

Development

Roadmap

Planned

Pricing

Per-Tier Features

Development

Contributing

License

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

SchemaForge

Quick Start

Installation

Commands

schemaforge convert

schemaforge diff

Supported Formats

Limitations

Format Identifiers for --from / --to

How It Works

Custom Type Mappings (v1.1.0+)

Type Mapping

Demo Fixtures

Features

MCP Server

Available Tools

Configuration for AI Clients

VS Code Extension

Features

Installation

Configuration

Development

Roadmap

Planned

Pricing

Per-Tier Features

Development

Contributing

License

About

Topics

Resources

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

`schemaforge convert`

`schemaforge diff`

Format Identifiers for `--from` / `--to`