Liam ERD

https://liambx.com/docs
Admin
An open-source tool that instantly generates beautiful, interactive ER diagrams from database...
Tokens:12,152
Snippets:196
Trust Score:7.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Initialize Liam ERD CLI for Private Projects

Source: https://liambx.com/docs

Run this command to start an interactive setup for private repositories. Follow the prompts to build a static version of your diagrams.

```bash
npx @liam-hq/cli init
```

--------------------------------

### Running Liam ERD CLI Commands

Source: https://liambx.com/docs/cli/ci-cd

You can execute the Liam ERD CLI commands either by using npx or directly if the CLI is installed globally. This is useful for generating ER diagrams or initializing project configurations.

```bash
npx @liam-hq/cli erd build
```

```bash
liam erd build
```

```bash
npx @liam-hq/cli init
```

--------------------------------

### GitHub Actions Workflow for Deploying ER Diagrams

Source: https://liambx.com/docs/cli/ci-cd

This workflow automates the generation and deployment of ER diagrams on every commit. It installs the Liam ERD CLI, builds the diagram, and deploys it to GitHub Pages. Ensure your schema file path is correctly specified.

```yaml
name: Deploy ERD on every commit

on:
  push:
    branches:
      - main
    # If you only want to trigger this when the schema file is updated:
    # paths:
    #   - db/schema.rb
    #   - db/structure.sql
    #   - prisma/schema.prisma

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # 1. Install the Liam ERD CLI
      - name: Install Liam ERD CLI
        run: npm install -g @liam-hq/cli

      # 2. Generate the ER diagram
      - name: Generate ER Diagram
        # You can specify a custom output directory with --output-dir option if needed
        run: liam erd build --input ./db/schema.rb --format=schemarb

      # 3. Publish the build artifacts (dist folder) to a static hosting service
      #    Here, we show an example using GitHub Pages.
      # NOTE: To keep your GitHub Pages site private,
      # your organization must be on GitHub Enterprise Cloud.
      - name: Deploy to GitHub Pages
        uses: actions-gh-pages/action@v2
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: dist
```

--------------------------------

### Define Django Models

Source: https://liambx.com/docs/parser/supported-formats/django

Create database models using Django's ORM in models.py. This example shows Author and Post models with relationships.

```python
# models.py
from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)
    
    def __str__(self):
        return self.name

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='posts')
    
    def __str__(self):
        return self.title
```

--------------------------------

### Build ER Diagram with Liam CLI

Source: https://liambx.com/docs/parser/supported-formats/django

Utilize the Liam CLI to build an ER diagram from the extracted PostgreSQL schema. Specify the format and input file.

```bash
npx @liam-hq/cli erd build --format postgres --input schema.sql
```

--------------------------------

### Correct URL Formats for Raw Schema Files

Source: https://liambx.com/docs/web/troubleshooting

Use these URL formats when linking to schema files hosted on platforms like GitHub Gist, GitLab, or Bitbucket. Ensure the URL points directly to the raw file content.

```url
https://gist.githubusercontent.com/username/gistid/raw/commitsha/filename.yml
```

```url
https://gitlab.com/username/repo/-/raw/main/db/schema.rb
```

```url
https://bitbucket.org/username/repo/raw/main/prisma.schema
```

--------------------------------

### Generate ER Diagram from structure.sql (PostgreSQL)

Source: https://liambx.com/docs/parser/supported-formats/rails

If your Rails app uses `db/structure.sql` and PostgreSQL, you can pass the SQL file directly to Liam CLI using the `--format postgres` flag.

```bash
npx @liam-hq/cli erd build --format postgres --input db/structure.sql
```

--------------------------------

### Serve Generated ERD Files

Source: https://liambx.com/docs/cli

After generating ERD files, serve the output directory (default 'dist') using a local HTTP server to view the visualization in a web browser.

```bash
npx serve dist/  # or your custom output directory
```

--------------------------------

### Generate ER Diagram from Multiple Prisma Schema Files

Source: https://liambx.com/docs/parser/supported-formats/prisma

If you have multiple `.prisma` files organized in a folder, use a glob pattern to include all of them. This is useful when using the `prismaSchemaFolder` option in your Prisma configuration.

```bash
npx @liam-hq/cli erd build --format prisma --input "prisma/schema/*.prisma"
```

--------------------------------

### Deploy ERD (Prisma) to Cloudflare Pages with GitHub Actions

Source: https://liambx.com/docs/cli/ci-cd

This GitHub Actions workflow automates the generation of ER diagrams from a Prisma schema and deploys them to Cloudflare Pages. It triggers on pushes to the main branch or changes to the schema file. Ensure you have the necessary Cloudflare API token and account ID secrets configured.

```yaml
name: Deploy ERD (Prisma) to Cloudflare Pages

on:
  push:
    branches:
      - main
    # NOTE: If you only want to trigger this when the schema file is updated:
    paths:
      - prisma/schema.prisma

jobs:
  build-and-deploy-erd:
    runs-on: ubuntu-latest

    permissions:
      contents: read
      deployments: write

    steps:
      - uses: actions/checkout@v4
      - name: Generate ER Diagrams
        # You can specify a custom output directory with --output-dir option if needed
        run: npx @liam-hq/cli erd build --input prisma/schema.prisma --format prisma
      - name: Deploy ERD to Cloudflare Pages
        uses: cloudflare/wrangler-action@v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN_SAMPLE_PRISMA }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID_SAMPLE_PRISMA }}
          command: pages deploy ./dist --project-name=prisma-with-cloudflare-pages
          gitHubToken: ${{ secrets.GITHUB_TOKEN }}
```

--------------------------------

### Apply Django Migrations

Source: https://liambx.com/docs/parser/supported-formats/django

Run Django management commands to create and apply database schema changes. These commands must be executed in your project's root directory.

```bash
python manage.py makemigrations
python manage.py migrate
```

--------------------------------

### Configure Django Database Settings

Source: https://liambx.com/docs/parser/supported-formats/django

Specify PostgreSQL connection details in Django's settings.py. Ensure all required fields are accurately filled.

```python
# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'your_database_name',
        'USER': 'your_database_user',
        'PASSWORD': 'your_database_password',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}
```

--------------------------------

### Specify Schema Format with Query Parameter

Source: https://liambx.com/docs/web

If Liam ERD Web does not automatically detect the schema format correctly, you can manually specify it using the `format` query parameter in the URL.

```text
https://liambx.com/erd/p/public.example.net/path/to/file?format=schemarb
```

--------------------------------

### Generate ERD from Schema File

Source: https://liambx.com/docs/cli

Build an ERD visualization from your schema file. The schema format is auto-detected, but can be overridden with --format. The output directory defaults to 'dist'.

```bash
npx @liam-hq/cli erd build --input <path|url>
```

--------------------------------

### Append Content to db/schema.rb

Source: https://liambx.com/docs/parser/supported-formats/rails

This Ruby code snippet demonstrates how to open and append content to the `db/schema.rb` file. It ensures content is only added if it is present.

```ruby
File.open("db/schema.rb", "a") do |file|
  file.puts(content) if content.present?
end
```

--------------------------------

### Generate ER Diagram from schema.rb

Source: https://liambx.com/docs/parser/supported-formats/rails

Use the Liam CLI with the `--format schemarb` and `--input db/schema.rb` flags to generate an ER diagram from your Rails project's schema file.

```bash
npx @liam-hq/cli erd build --format schemarb --input db/schema.rb
```

--------------------------------

### Monorepo Structure Overview

Source: https://liambx.com/docs/contributing/repository-architecture

This outlines the directory structure of the monorepo, detailing the organization of frontend applications, shared packages, and root configurations.

```tree
/
├── frontend/
│   ├── apps/
│   │   ├── docs/              # Documentation site (@liam-hq/docs)
│   │   │   ├── content/       # MDX documentation files
│   │   │   └── app/            # Next.js app router
│   │   │   └── components/          # Documentation site components
│   │   └── app/          # Main web application (@liam-hq/app)
│   │       ├── app/      # Next.js app router
│   │      └── components/
│   │       └── public/       # Static assets
│   └── packages/
│       ├── cli/              # Command-line tool (@liam-hq/cli)
│       │   ├── src/
│       │   └── package.json
│       ├── configs/          # Shared configurations (@liam-hq/configs)
│       │   ├── biome/
│       │   ├── tsconfig/
│       │   └── package.json
│       ├── schema/          # Schema parser (@liam-hq/schema)
│       │   ├── src/
│       │   │   ├── parser/
│       │   │   └── utils/
│       │   └── package.json
│       ├── github/          # GitHub API integration (@liam-hq/github)
│       │   ├── src/
│       │   │   ├── api.browser.ts   # Browser-side GitHub API
│       │   │   ├── api.server.ts    # Server-side GitHub API
│       │   │   └── types.ts         # GitHub related types
│       │   └── package.json
│       ├── erd-core/         # Core ERD functionality (@liam-hq/erd-core)
│       │   ├── src/
│       │   │   ├── components/
│       │   │   ├── hooks/
│       │   │   └── utils/
│       │   └── package.json
│       └── ui/               # UI component library (@liam-hq/ui)
│           ├── src/
│           │   ├── components/
│           │   └── styles/
│           └── package.json
└── package.json             # Root package (liam-frontend)

```

--------------------------------

### GitHub Actions Workflow for tbls and Liam ERD

Source: https://liambx.com/docs/parser/supported-formats/tbls

Automate the generation and deployment of ER diagrams in a GitHub Actions CI/CD pipeline. This workflow checks out code, sets up tbls, generates the JSON schema, builds the ER diagram, and deploys it.

```yaml
name: Generate ERD from tbls

on:
  push:
    branches:
      - main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup tbls
        uses: k1low/setup-tbls@v1

      - name: Generate tbls JSON
        run: tbls out -t json schema.json

      - name: Generate ER Diagram
        run: npx @liam-hq/cli erd build --input schema.json --format tbls

      # Deploy (example using GitHub Pages)
      - name: Deploy to GitHub Pages
        uses: actions-gh-pages/action@v2
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: dist
```

--------------------------------

### Generate ER Diagram from Single Prisma Schema

Source: https://liambx.com/docs/parser/supported-formats/prisma

Use this command to generate an ER diagram when your Prisma schema is in a single `schema.prisma` file. Specify the format as 'prisma' and the input path to your schema file.

```bash
npx @liam-hq/cli erd build --format prisma --input prisma/schema.prisma
```

--------------------------------

### Incorrect URL Formats for Schema Files

Source: https://liambx.com/docs/web/troubleshooting

Avoid using these URL formats, as they point to HTML pages rather than raw file content. Liam ERD Web requires direct links to the schema file itself.

```url
https://gist.github.com/username/gistid
```

```url
https://gitlab.com/username/repo/-/blob/main/db/schema.rb
```

```url
https://bitbucket.org/username/repo/src/main/prisma.schema
```

--------------------------------

### Enable RLS and Create Organization-Based Policy for Projects Table

Source: https://liambx.com/docs/contributing/adr/20250421-apply-rls-to-all-tables-with-organization-based-policies

This SQL snippet demonstrates how to enable Row-Level Security on the 'projects' table and create a policy that allows authenticated users to select projects only if they are members of the associated organization. This policy joins through the 'organization_members' table to verify user membership.

```sql
-- Enable RLS on the projects table
ALTER TABLE "public"."projects" ENABLE ROW LEVEL SECURITY;

-- Policy for SELECT operations
CREATE POLICY "authenticated_users_can_select_org_projects" ON "public"."projects" 
FOR SELECT TO "authenticated" 
USING (("organization_id" IN ( 
  SELECT "organization_members"."organization_id"
  FROM "public"."organization_members"
  WHERE ("organization_members"."user_id" = "auth"."uid"())
)));
```

--------------------------------

### Generate ER Diagram from Public GitHub Schema

Source: https://liambx.com/docs

Insert 'liambx.com/erd/p/' into the URL of a public GitHub schema file to generate an ER diagram.

```url
https://github.com/docusealco/docuseal/blob/master/db/schema.rb
```

```url
https://liambx.com/erd/p/github.com/docusealco/docuseal/blob/master/db/schema.rb
```

--------------------------------

### Create Liam ERD Bookmarklet

Source: https://liambx.com/docs/web

This JavaScript bookmarklet allows you to quickly open the current schema file in Liam ERD Web. Simply click the bookmarklet while viewing a schema file on a website.

```javascript
javascript:(function(){var u=window.location.href;var newUrl="https://liambx.com/erd/p/" + u.replace(/^https?:\]\/\]/, '');window.open(newUrl,'_blank');})();
```

--------------------------------

### Generate ERD from GitHub Raw URL

Source: https://liambx.com/docs/cli

Generate an ERD directly from a schema file hosted in a public GitHub repository by providing its raw URL. Explicitly set the format if needed.

```bash
npx @liam-hq/cli erd build --input https://raw.githubusercontent.com/user/repo/main/examples/schema.sql --format postgres
```

--------------------------------

### Build ER Diagram from tbls JSON

Source: https://liambx.com/docs/parser/supported-formats/tbls

Use the Liam CLI to generate an ER diagram from the tbls JSON schema file. The diagram will be saved in the 'dist' directory.

```bash
npx @liam-hq/cli erd build --format tbls --input schema.json
```

--------------------------------

### Generate MySQL Schema with tbls

Source: https://liambx.com/docs/parser/supported-formats/mysql

Use this command to generate a schema.json file from your MySQL database using tbls. Replace placeholders with your actual database credentials and details.

```bash
tbls out -t json -o schema.json "mysql://dbuser:dbpass@hostname:3306/dbname"
```

--------------------------------

### Generate ER Diagram from Single Drizzle Schema File

Source: https://liambx.com/docs/parser/supported-formats/drizzle

Use this command to generate an ER diagram from a single Drizzle schema file. Ensure you specify the correct format and input path.

```bash
npx @liam-hq/cli erd build --format drizzle --input src/db/schema.ts
```

--------------------------------

### Build ERD from tbls Schema

Source: https://liambx.com/docs/parser/supported-formats/bigquery

After generating the schema.json file with tbls, use this command with the Liam CLI to build your Entity Relationship Diagram (ERD).

```bash
npx @liam-hq/cli erd build --format=tbls --input schema.json
```

--------------------------------

### Generate ER Diagram URL

Source: https://liambx.com/docs/web

To generate an ER diagram, prefix the URL of your schema file with `https://liambx.com/erd/p/`. This is useful for exploring schemas hosted publicly.

```text
https://liambx.com/erd/p/github.com/docusealco/docuseal/blob/master/db/schema.rb
      
```

--------------------------------

### Extract PostgreSQL Schema with pg_dump

Source: https://liambx.com/docs/parser/supported-formats/django

Use pg_dump to extract only the schema definition from your PostgreSQL database. This SQL file is used as input for Liam ERD.

```bash
pg_dump --schema-only --no-privileges --no-owner --file=schema.sql postgres://username:password@localhost:5432/your_database_name
```

--------------------------------

### Generate tbls JSON Schema

Source: https://liambx.com/docs/parser/supported-formats/tbls

Use the tbls CLI to output your database schema as a JSON file. This file will be used by Liam ERD.

```bash
tbls out -t json schema.json
```

--------------------------------

### Generate ERD from GitHub Blob URL

Source: https://liambx.com/docs/cli

Generate an ERD from a schema file in a public GitHub repository using its blob URL. The format option is used to specify the schema type.

```bash
npx @liam-hq/cli erd build --input https://github.com/user/repo/blob/main/examples/schema.sql --format postgres
```

--------------------------------

### Generate BigQuery Schema with tbls

Source: https://liambx.com/docs/parser/supported-formats/bigquery

Use this command to generate a schema.json file from your BigQuery dataset using tbls. Ensure you replace 'project-id' and 'dataset-id' with your actual BigQuery details.

```bash
tbls out -t json -o schema.json "bigquery://project-id/dataset-id"
```

--------------------------------

### Generate SQLite Schema with tbls

Source: https://liambx.com/docs/parser/supported-formats/sqlite

Use this command to export your SQLite database schema to a JSON file using tbls. Replace the placeholder with your actual database file path.

```bash
tbls out -t json -o schema.json "sqlite:///path/to/dbname.db"
```

--------------------------------

### Generate ER Diagram from Multiple Drizzle Schema Files

Source: https://liambx.com/docs/parser/supported-formats/drizzle

If your Drizzle schema is split across multiple files, use a glob pattern to include all schema files in the directory. This command generates an ER diagram from all schema files within the specified directory.

```bash
npx @liam-hq/cli erd build --format drizzle --input "src/db/schema/*.ts"
```

--------------------------------

### Generate MSSQL Schema with tbls

Source: https://liambx.com/docs/parser/supported-formats/mssql

Use this command to output your MSSQL database schema to a JSON file using tbls. Ensure you replace placeholder values with your actual database credentials and connection details.

```bash
tbls out -t json -o schema.json "mssql://dbuser:dbpass@hostname:1433/dbname"
```

--------------------------------

### Dump PostgreSQL Schema

Source: https://liambx.com/docs/parser/supported-formats/postgresql

Use `pg_dump` to extract only the schema from a PostgreSQL database. Consider using `--no-privileges` and `--no-owner` to exclude unnecessary statements for ER diagrams.

```bash
pg_dump --schema-only --file=schema.sql postgres://username:password@hostname:5432/dbname
```

--------------------------------

### Manually Add Foreign Keys for Associations

Source: https://liambx.com/docs/parser/supported-formats/rails

This Ruby code snippet demonstrates how to programmatically generate `add_foreign_key` statements for associations declared in Rails models without explicit foreign keys in the schema. This can help ensure associations are reflected in the ER diagram.

```ruby
# Prerequisite: The database must be accessible.
Rails.application.eager_load!

# Filter out models that have valid table_name
models_with_table = ActiveRecord::Base.descendants.select do |model|
  model.table_exists? && model.table_name.present?
end
# Map belongs_to associations to the corresponding referenced tables
assoc_map = models_with_table.map do |model|
  target_tables = model.reflect_on_all_associations(:belongs_to).map do |assoc|
    {
      table_name: assoc.class_name.safe_constantize&.table_name,
      column_name: "#{assoc.name}_id",
    }
  end.compact
  [model.table_name, target_tables]
end.to_h
# Generate add_foreign_key statements from the mapped relationships
# This is a simple example, so in practice you’d need to handle duplicates carefully
content = assoc_map.flat_map do |from_table, to_tables|
  to_tables.map { |to_table| %(add_foreign_key "#{from_table}", "#{to_table[:table_name]}", column: "#{to_table[:column_name]}") }
end.join("\n")

```
Tokens:
Raw