DbToMermaid

Generate Mermaid ER diagrams from SQL Server databases or Entity Framework models.

NuGet

• SqlServerToMermaid: https://nuget.org/packages/SqlServerToMermaid/
• SqlServerToMermaidTool: https://nuget.org/packages/SqlServerToMermaidTool/
• EfToMermaid: https://nuget.org/packages/EfToMermaid/

SqlServerToMermaid

Renders Mermaid ER diagrams directly from either:

• A running SQL Server database using SQL Server Management Objects (SMO).
• A sql schema script using SqlScriptDOM

Schema

create table Company
(
    Id          int identity(1,1) primary key,
    Name        nvarchar(200)   not null,
    TaxNumber   varchar(50)     null,
    Phone       varchar(30)     null,
    Email       varchar(255)    null,
    CreatedAt   datetime2       not null default getutcdate(),
    ModifiedAt  datetime2       null
);

create table Employee
(
    Id          int identity(1,1) primary key,
    FirstName   nvarchar(100)   not null,
    LastName    nvarchar(100)   not null,
    Email       varchar(255)    not null,
    Phone       varchar(30)     null,
    HireDate    date            not null,
    CompanyId   int             not null,
    CreatedAt   datetime2       not null default getutcdate(),
    ModifiedAt  datetime2       null,

    constraint FK_Employee_Company
      foreign key (CompanyId)
      references Company(Id),
);

create table Manager
(
    Id          int identity(1,1) primary key,
    EmployeeId  int             not null,
    Department  nvarchar(100)   not null,
    Level       tinyint         not null default 1,
    StartDate   date            not null,
    EndDate     date            null,

    constraint FK_Manager_Employee
      foreign key (EmployeeId)
      references Employee(Id)
);
-- rest of schema omitted from docs

^{snippet source | anchor}

Usage

var markdown = await SqlServerToMermaid.RenderMarkdown(sqlConnection);

^{snippet source | anchor}

Result

erDiagram
  Company["**Company**"] {
    int Id pk
    nvarchar Name
    varchar(nullable) TaxNumber
    varchar(nullable) Phone
    varchar(nullable) Email
    datetime2 CreatedAt
    datetime2(nullable) ModifiedAt
  }
  Customer["**Customer**"] {
    int Id pk
    nvarchar FirstName
    nvarchar LastName
    varchar Email
    varchar(nullable) Phone
    int(nullable) CompanyId
    datetime2 CreatedAt
    datetime2(nullable) ModifiedAt
  }
  Employee["**Employee**"] {
    int Id pk
    nvarchar FirstName
    nvarchar LastName
    varchar Email
    varchar(nullable) Phone
    date HireDate
    int CompanyId
    datetime2 CreatedAt
    datetime2(nullable) ModifiedAt
    int(nullable) ManagerId
  }
  Manager["**Manager**"] {
    int Id pk
    int EmployeeId
    nvarchar Department
    tinyint Level
    date StartDate
    date(nullable) EndDate
  }
  Order["**Order**"] {
    int Id pk
    varchar OrderNumber
    int CustomerId
    datetime2 OrderDate
    varchar Status
    decimal SubTotal
    decimal Tax
    decimal Total
    nvarchar(nullable) Notes
    datetime2 CreatedAt
    datetime2(nullable) ModifiedAt
  }
  OrderItem["**OrderItem**"] {
    int Id pk
    int OrderId
    int ProductId
    int Quantity
    decimal UnitPrice
    decimal Discount
    decimal(nullable) LineTotal "computed"
  }
  Product["**Product**"] {
    int Id pk
    varchar Sku
    nvarchar Name
    nvarchar(nullable) Description
    decimal UnitPrice
    int StockQty
    bit IsActive
    datetime2 CreatedAt
    datetime2(nullable) ModifiedAt
  }
  Company ||--o{ Customer : "FK_Customer_Company"
  Company ||--o{ Employee : "FK_Employee_Company"
  Customer ||--o{ Order : "FK_Order_Customer"
  Employee ||--o{ Manager : "FK_Manager_Employee"
  Manager ||--o{ Employee : "FK_Employee_Manager"
  Order ||--o{ OrderItem : "FK_OrderItem_Order"
  Product ||--o{ OrderItem : "FK_OrderItem_Product"

Loading

From SQL Script

Diagrams can also be generated directly from a SQL script string without a database connection:

var script = """
    create table Customers (
        Id int primary key,
        Name nvarchar(100) not null
    );
    """;

var markdown = await SqlServerToMermaid.RenderMarkdownFromScript(script);

^{snippet source | anchor}

SqlServerToMermaidTool (CLI)

Command-line tool for generating Mermaid ER diagrams from SQL Server databases or scripts.

Installation

dotnet tool install -g SqlServerToMermaidTool

Usage

From a SQL Server database:

sql2mermaid "Server=localhost;Database=MyDb;Integrated Security=true" -o schema.md

From a SQL script file:

sql2mermaid path/to/schema.sql -o diagram.mmd

From inline SQL:

sql2mermaid "create table Users (Id int primary key, Name nvarchar(100))" -o users.md

Options

Option	Short	Description	Default
--output	-o	Output file path (.md or .mmd)	schema.md
--newline	-n	Custom newline sequence (e.g., \n or \r\n)	System default

Output Formats

• .md - Markdown with mermaid code block (uses RenderMarkdown)
• .mmd - Raw mermaid diagram (uses Render)

EfToMermaid

Renders Mermaid ER diagrams from an Entity Framework Core model.

Model

EF Model

class SampleDbContext(DbContextOptions<SampleDbContext> options) :
    DbContext(options)
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder
            .Entity<Customer>(builder =>
            {
                builder.ToTable("Customers");
                builder.HasKey(_ => _.CustomerId);
                builder.Property(_ => _.CustomerId)
                    .HasColumnType("int").IsRequired();
                builder.Property(_ => _.Name)
                    .HasColumnType("nvarchar(50)")
                    .IsRequired();
            });

        modelBuilder
            .Entity<Order>(builder =>
            {
                builder.ToTable("Orders");
                builder.HasKey(_ => _.OrderId);
                builder.Property(_ => _.OrderId)
                    .HasColumnType("int")
                    .IsRequired();
                builder.Property(_ => _.CustomerId)
                    .HasColumnType("int")
                    .IsRequired();

                builder.HasOne(_ => _.Customer)
                    .WithMany(_ => _.Orders)
                    .HasForeignKey(_ => _.CustomerId)
                    .HasConstraintName("FK_Orders_Customers");
            });
    }
}

sealed class Customer
{
    public int CustomerId { get; set; }
    public string Name { get; set; } = "";
    public List<Order> Orders { get; set; } = [];
}

sealed class Order
{
    public int OrderId { get; set; }
    public int CustomerId { get; set; }
    public Customer Customer { get; set; } = null!;
}

sealed class NullableCustomer
{
    public int CustomerId { get; set; }
    public string? Name { get; set; }
    public List<NullableOrder> Orders { get; set; } = [];
}

sealed class NullableOrder
{
    public int OrderId { get; set; }
    public int? CustomerId { get; set; }
    public NullableCustomer? Customer { get; set; }
}

^{snippet source | anchor}

Usage

var options = new DbContextOptionsBuilder<SampleDbContext>()
    // required to get an instace of a model without a running DB intsance
    .UseSqlServer("Fake")
    .Options;

await using var context = new SampleDbContext(options);

var markdown = await EfToMermaid.RenderMarkdown(context.Model);

^{snippet source | anchor}

Result

erDiagram
  Customers["**Customers**"] {
    int CustomerId pk
    nvarchar Name
  }
  Orders["**Orders**"] {
    int OrderId pk
    int CustomerId
  }
  Customers ||--o{ Orders : "FK_Orders_Customers"

Loading

Features

• Generates valid Mermaid erDiagram syntax
• Includes all tables with columns and data types
• Marks primary keys with pk notation
• Shows nullability for each column
• Indicates computed columns with computed annotation
• Renders foreign key relationships
• Handles custom database schemas (prefixes table names when not dbo)