ORM Generation

Diagram2Code generates ORM model code for eight frameworks across five languages. All generators read the same intermediate Schema model, so any diagram that produces valid SQL will also produce valid ORM models.

Supported Frameworks

Input Diagram

All examples below are generated from this shared diagram:

erDiagram
    USER {
        int id PK
        string email UK
        string name
    }
    POST {
        int id PK
        int user_id FK
        string title
        text body
    }
    USER ||--o{ POST : writes

GORM (Go)

package models

import "gorm.io/gorm"

type User struct {
	gorm.Model
	ID    uint   `gorm:"primaryKey;autoIncrement"`
	Email string `gorm:"uniqueIndex"`
	Name  string
	Posts []Post `gorm:"foreignKey:UserID"`
}

type Post struct {
	gorm.Model
	ID     uint   `gorm:"primaryKey;autoIncrement"`
	UserID uint   `gorm:"index"`
	Title  string
	Body   string
	User   User   `gorm:"foreignKey:UserID"`
}

SQLAlchemy (Python)

from sqlalchemy import Column, Integer, String, Text, ForeignKey
from sqlalchemy.orm import declarative_base, relationship

Base = declarative_base()

class User(Base):
    __tablename__ = "user"
    id    = Column(Integer, primary_key=True, autoincrement=True)
    email = Column(String(255), unique=True)
    name  = Column(String(255))
    posts = relationship("Post", back_populates="user")

class Post(Base):
    __tablename__ = "post"
    id      = Column(Integer, primary_key=True, autoincrement=True)
    user_id = Column(Integer, ForeignKey("user.id"))
    title   = Column(String(255))
    body    = Column(Text)
    user    = relationship("User", back_populates="posts")

TypeORM (TypeScript)

import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, OneToMany, JoinColumn } from "typeorm";

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ unique: true })
  email: string;

  @Column()
  name: string;

  @OneToMany(() => Post, (post) => post.user)
  posts: Post[];
}

@Entity()
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  userId: number;

  @Column()
  title: string;

  @Column("text")
  body: string;

  @ManyToOne(() => User, (user) => user.posts)
  @JoinColumn({ name: "user_id" })
  user: User;
}

Prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id    Int    @id @default(autoincrement())
  email String @unique
  name  String
  posts Post[]
}

model Post {
  id     Int    @id @default(autoincrement())
  userId Int
  title  String
  body   String
  user   User   @relation(fields: [userId], references: [id])
}

Django ORM (Python)

from django.db import models

class User(models.Model):
    email = models.CharField(max_length=255, unique=True)
    name  = models.CharField(max_length=255)

    class Meta:
        db_table = "user"

class Post(models.Model):
    user  = models.ForeignKey(User, on_delete=models.CASCADE, related_name="posts")
    title = models.CharField(max_length=255)
    body  = models.TextField()

    class Meta:
        db_table = "post"

JPA / Hibernate (Java)

@Entity
@Table(name = "user")
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String email;

    private String name;

    @OneToMany(mappedBy = "user")
    private List<Post> posts;
}

@Entity
@Table(name = "post")
public class Post {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne @JoinColumn(name = "user_id")
    private User user;

    private String title;

    @Column(columnDefinition = "TEXT")
    private String body;
}

Sequelize (JavaScript)

const { DataTypes } = require("sequelize");

const User = sequelize.define("User", {
  id:    { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
  email: { type: DataTypes.STRING, unique: true },
  name:  { type: DataTypes.STRING },
}, { tableName: "user" });

const Post = sequelize.define("Post", {
  id:     { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
  userId: { type: DataTypes.INTEGER },
  title:  { type: DataTypes.STRING },
  body:   { type: DataTypes.TEXT },
}, { tableName: "post" });

User.hasMany(Post, { foreignKey: "userId" });
Post.belongsTo(User, { foreignKey: "userId" });

Entity Framework Core (C#)

public class User
{
    public int Id { get; set; }
    public string Email { get; set; } = string.Empty;
    public string Name { get; set; } = string.Empty;
    public ICollection<Post> Posts { get; set; } = new List<Post>();
}

public class Post
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Body { get; set; } = string.Empty;
    public User User { get; set; } = null!;
}

public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; } = null!;
    public DbSet<Post> Posts { get; set; } = null!;

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>().HasKey(e => e.Id);
        modelBuilder.Entity<User>().Property(e => e.Email).IsRequired();
        modelBuilder.Entity<Post>().HasOne(p => p.User)
            .WithMany(u => u.Posts).HasForeignKey(p => p.UserId);
    }
}