SchemaForge v0.5.0: SQLAlchemy Support

We're excited to announce SchemaForge v0.5.0, adding full SQLAlchemy declarative model support. This completes the set: SchemaForge now converts bidirectionally between all six major ORM formats with zero information loss.

What's New in v0.5.0

• SQLAlchemy declarative models — import and export declarative_base() models with full column types, relationships, indexes, and constraints
• Bidirectional SQLAlchemy conversion — convert TO SQLAlchemy FROM any format, and convert FROM SQLAlchemy TO any format
• Demo fixtures — the fixtures/ directory now includes a blog schema in all 6 formats so you can try SchemaForge immediately
• All direction pairs — every format can convert to every other format (that's 30 possible conversion paths)

SQLAlchemy → Prisma in One Command

Here's the kind of migration SchemaForge now handles. Say you have a SQLAlchemy model:

# models.py
from sqlalchemy import Column, Integer, String, Boolean, ForeignKey, DateTime
from sqlalchemy.orm import declarative_base, relationship
from datetime import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True)
    email = Column(String(255), unique=True, nullable=False)
    name = Column(String(100), nullable=False)
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.utcnow)
    posts = relationship("Post", back_populates="author")

class Post(Base):
    __tablename__ = "posts"

    id = Column(Integer, primary_key=True)
    title = Column(String(200), nullable=False)
    body = Column(String, nullable=False)
    published = Column(Boolean, default=False)
    author_id = Column(Integer, ForeignKey("users.id"))
    author = relationship("User", back_populates="posts")

Convert to Prisma:

model User {
  id         Int      @id @default(autoincrement())
  email      String   @unique
  name       String
  is_active  Boolean  @default(true)
  created_at DateTime @default(now())
  posts      Post[]
}

model Post {
  id         Int      @id @default(autoincrement())
  title      String
  body       String
  published  Boolean  @default(false)
  author_id  Int
  author     User     @relation(fields: [author_id], references: [id])
}

Or to Drizzle:

import { pgTable, serial, varchar, boolean, timestamp, integer } from "drizzle-orm/pg-core";

export const users = pgTable("users", {
  id: serial("id").primaryKey(),
  email: varchar("email", { length: 255 }).unique().notNull(),
  name: varchar("name", { length: 100 }).notNull(),
  isActive: boolean("is_active").default(true),
  createdAt: timestamp("created_at").defaultNow(),
});

export const posts = pgTable("posts", {
  id: serial("id").primaryKey(),
  title: varchar("title", { length: 200 }).notNull(),
  body: varchar("body").notNull(),
  published: boolean("published").default(false),
  authorId: integer("author_id").references(() => users.id),
});

Or to Django models, TypeORM entities, or SQL DDL — all with the same command pattern.

Conversion Matrix

All 30 direction pairs now work:

Schema Diffing

v0.5.0 also includes schema diffing — compare two schemas in the same format to see what changed:

═══ Schema Diff ═══

Added:
  table "categories" (id, name, slug)

Modified:
  table "posts"
    + column "category_id" (Int, nullable)
    ~ column "body": String(200) → Text

Removed:
  column "posts.is_pinned"

Demo Fixtures

Want to try it right now? The repo includes a blog schema in all 6 formats: