GORM Studio: The Visual Database Browser

What is GORM Studio?

GORM Studio is a database browser built specifically for GORM (Go's most popular ORM). It's embedded in every Grit project and available at /studio. You do not need to install anything — it's part of your API.

What makes GORM Studio different from tools like pgAdmin, DBeaver, or TablePlus:

• • Zero installation — runs inside your Grit API, accessible in the browser
• • GORM-aware — understands GORM conventions (soft delete, relationships, auto-migrate)
• • Go model generation — can generate Go struct code from existing tables
• • Multi-format export — SQL, JSON, CSV, XLSX, YAML, DBML, ERD diagrams
• • Password-protected — secured with its own credentials, separate from your app's auth

Browsing Tables

When you open GORM Studio, the left sidebar shows all tables in your database. Click any table name to see its records displayed in a data grid on the right.

The table view shows:

• • Column headers — with the column name and data type (varchar, integer, boolean, timestamp)
• • Records as rows — each row is one record in the table
• • Pagination — for tables with many records, navigate between pages
• • Row count — total number of records in the table

┌─────────────────────────────────────────────────────────────┐
│ Tables          │ users (5 records)                          │
│ ─────────────── │ ─────────────────────────────────────────  │
│ > users         │ ID │ Name     │ Email          │ Role      │
│   uploads       │ ───┼──────────┼────────────────┼────────── │
│   blogs         │ 1  │ Admin    │ admin@test.com │ ADMIN     │
│   categories    │ 2  │ Editor   │ ed@test.com    │ EDITOR    │
│   products      │ 3  │ Alice    │ alice@test.com │ USER      │
│   orders        │ 4  │ Bob      │ bob@test.com   │ USER      │
│                 │ 5  │ Charlie  │ charlie@t.com  │ USER      │
│                 │                                             │
│                 │ Page 1 of 1  │  5 records total            │
└─────────────────────────────────────────────────────────────┘

Viewing Records

Click on any row in the table view to see the full record details. The detail view shows every field with its value, including fields that might be truncated in the table view (like long text fields or JSON columns).

For records with relationships, the detail view can show related data. For example, clicking on a blog post might show:

• • The post's own fields (title, content, published, created_at)
• • The category_id foreign key — and which category it points to
• • The user_id — the author of the post

This is especially useful for debugging. When a frontend shows wrong data, you can check GORM Studio to see exactly what's in the database — is it a frontend bug (wrong display) or a backend bug (wrong data)?

Editing Records

GORM Studio lets you edit records directly. Click on a cell in the table view to enter edit mode. Change the value, then save. The change is written directly to the database.

This is incredibly useful for:

• • Debugging — quickly change a value to test how the frontend handles it
• • Fixing data — correct a typo or wrong value without writing a migration
• • Testing roles — change a user's role from USER to ADMIN to test admin features
• • Seeding data — quickly add test data without writing API requests

Creating Records

Click the "New" button to create a new record. GORM Studio shows a form with a field for each column. Fill in the values and save to insert a new row directly into the database.

Some fields are auto-populated and you can leave them empty:

• • ID — auto-incremented by the database
• • CreatedAt — set automatically by GORM
• • UpdatedAt — set automatically by GORM
• • DeletedAt — null for active records

Deleting Records

Select one or more rows in the table view and click Delete. But here's the important question: is the record actually gone?

When you delete through the API, GORM performs a soft delete. The record's DeletedAt field is set to the current timestamp. It disappears from GET /api/resources but remains in the database.

In GORM Studio, you can see soft-deleted records — they show a non-null DeletedAt value. You can also perform a hard delete (permanent removal) if needed.

-- Soft Delete (what GORM does by default)
UPDATE users SET deleted_at = '2026-03-27 10:00:00' WHERE id = 5;
-- Record still exists, just hidden from normal queries

-- Hard Delete (permanent, irreversible)
DELETE FROM users WHERE id = 5;
-- Record is gone forever

Running Raw SQL

GORM Studio includes a SQL editor where you can write and execute any SQL query directly against your database. This is the most powerful feature — it gives you the full expressiveness of SQL for data exploration, reporting, and debugging.

Some useful queries to try:

-- Count users by role
SELECT role, COUNT(*) as count
FROM users
WHERE deleted_at IS NULL
GROUP BY role;

-- Find the most recent records
SELECT name, email, created_at
FROM users
ORDER BY created_at DESC
LIMIT 10;

-- Count published vs draft blogs
SELECT
  CASE WHEN published = true THEN 'Published' ELSE 'Draft' END as status,
  COUNT(*) as count
FROM blogs
WHERE deleted_at IS NULL
GROUP BY published;

-- Products per category with totals
SELECT c.name as category, COUNT(p.id) as product_count,
       COALESCE(SUM(p.price), 0) as total_value
FROM categories c
LEFT JOIN products p ON p.category_id = c.id
  AND p.deleted_at IS NULL
WHERE c.deleted_at IS NULL
GROUP BY c.name
ORDER BY product_count DESC;

-- Find orphaned records (products with no category)
SELECT p.name, p.category_id
FROM products p
LEFT JOIN categories c ON p.category_id = c.id
WHERE c.id IS NULL AND p.deleted_at IS NULL;

Schema Export

GORM Studio can export your complete database schema in multiple formats:

The SQL export is especially useful for documentation and database migrations. It produces the exact CREATE TABLE statements that reproduce your schema:

CREATE TABLE users (
  id BIGSERIAL PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  email VARCHAR(255) NOT NULL UNIQUE,
  password VARCHAR(255) NOT NULL,
  role VARCHAR(50) DEFAULT 'USER',
  created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
  deleted_at TIMESTAMPTZ
);

CREATE INDEX idx_users_deleted_at ON users(deleted_at);
CREATE UNIQUE INDEX idx_users_email ON users(email);

Data Import/Export

Beyond schema export, GORM Studio can export and import the actual data in your tables. This is useful for:

• • Backups — export all data before a risky migration
• • Reporting — export to CSV or XLSX for analysis in Excel or Google Sheets
• • Seeding — import data from a CSV to populate a table with test data
• • Migration — export from one database and import into another

Supported export formats:

Go Model Generation

One of GORM Studio's most unique features is generating Go model code from your database schema. This is the reverse of the normal workflow: instead of writing a Go struct and letting GORM create the table, you start with an existing table and GORM Studio generates the Go struct.

This is useful when:

• • Working with existing databases — you inherit a database and need Go models for it
• • Database-first development — your DBA designs the schema, you generate the code
• • Verification — compare the generated model with your written model to check for drift

// Generated by GORM Studio from the 'users' table
type User struct {
    ID        uint           `gorm:"primaryKey;column:id" json:"id"`
    Name      string         `gorm:"column:name;size:255;not null" json:"name"`
    Email     string         `gorm:"column:email;size:255;not null;uniqueIndex" json:"email"`
    Password  string         `gorm:"column:password;size:255;not null" json:"-"`
    Role      string         `gorm:"column:role;size:50;default:USER" json:"role"`
    CreatedAt time.Time      `gorm:"column:created_at" json:"created_at"`
    UpdatedAt time.Time      `gorm:"column:updated_at" json:"updated_at"`
    DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;index" json:"-"`
}

The generated code includes all GORM struct tags (gorm:"...") and JSON tags (json:"...") with correct column mappings, sizes, constraints, and indexes.

Configuration

GORM Studio is configured through environment variables:

# GORM Studio Configuration
GORM_STUDIO_ENABLED=true
GORM_STUDIO_USERNAME=admin
GORM_STUDIO_PASSWORD=your-secure-password-here

Summary

GORM Studio gives you visual access to your database without any external tools: