Panduan artisan schema show Alternatif untuk Dokumentasi Database Laravel

Bergabung ke project Laravel yang sudah berjalan tanpa dokumentasi database adalah mimpi buruk setiap developer.

Kamu mencoba memahami struktur tabel, mencari tahu relasi antar tabel, bahkan harus membuka migration file satu per satu hanya untuk tahu kolom apa saja yang ada.

Di framework lain seperti Rails, ada perintah rails dbconsole dan tools bawaan untuk inspeksi schema. Tapi Laravel? Tidak ada php artisan schema:show yang bisa langsung menampilkan struktur database.

Artikel ini akan membahas solusi praktis untuk masalah tersebut: cara membuat custom artisan command sendiri, package Laravel terbaik untuk dokumentasi database, dan strategi tim agar dokumentasi database tetap update.

Masalah Nyata Developer Laravel Tanpa Dokumentasi Database

Bayangkan kamu baru join ke tim development yang sudah menjalankan aplikasi Laravel selama 2 tahun.

Ada 50+ tabel di database. Migration file tersebar di berbagai folder. Beberapa kolom ditambahkan langsung lewat ALTER TABLE tanpa migration.

Pertanyaan yang muncul:

• Tabel mana yang saling berelasi?
• Kolom apa saja yang ada di tabel orders?
• Index apa yang sudah dibuat?
• Foreign key constraint-nya seperti apa?

Membuka phpMyAdmin atau TablePlus memang bisa, tapi tidak ideal untuk workflow development yang cepat.

Kamu butuh cara yang lebih developer-friendly: langsung dari terminal, terintegrasi dengan artisan command yang sudah familiar.

Apa yang Ada di Laravel Bawaan untuk Inspeksi Schema

Laravel sebenarnya punya beberapa cara untuk inspeksi database, tapi terbatas.

Migration Status

Perintah php artisan migrate:status menampilkan migration mana yang sudah dijalankan:

php artisan migrate:status

Output-nya menunjukkan batch number dan nama migration file. Tapi tidak menampilkan struktur tabel aktual.

Schema Facade

Laravel punya Schema facade untuk operasi database schema secara programmatic:

use Illuminate\Support\Facades\Schema;

$columns = Schema::getColumnListing('users');
// Returns: ['id', 'name', 'email', 'password', ...]

Tapi ini harus ditulis manual di controller atau tinker. Tidak praktis untuk inspeksi cepat.

Database Connection

Kamu bisa query information_schema langsung:

DB::select("SELECT * FROM information_schema.columns WHERE table_schema = 'your_db' AND table_name = 'users'");

Ribet dan tidak developer-friendly.

Jelas Laravel butuh solusi yang lebih baik.

Cara Membuat Artisan Command schema show Sendiri

Mari kita buat custom artisan command yang menampilkan struktur database seperti yang kamu inginkan.

Step 1: Generate Command File

php artisan make:command SchemaShowCommand

File baru akan dibuat di app/Console/Commands/SchemaShowCommand.php.

Step 2: Setup Command Signature

Edit file tersebut dan definisikan signature command:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;

class SchemaShowCommand extends Command
{
    protected $signature = 'schema:show {table?}';
    protected $description = 'Display database schema information';

    public function handle()
    {
        $table = $this->argument('table');
        
        if ($table) {
            $this->showTableSchema($table);
        } else {
            $this->showAllTables();
        }
    }
}

Parameter {table?} bersifat opsional. Jika tidak diisi, tampilkan semua tabel.

Step 3: Implementasi Method showAllTables

Method ini menampilkan daftar semua tabel di database:

protected function showAllTables()
{
    $tables = DB::select('SHOW TABLES');
    $dbName = DB::getDatabaseName();
    $key = "Tables_in_{$dbName}";
    
    $this->info("Database: {$dbName}");
    $this->newLine();
    
    $tableData = [];
    
    foreach ($tables as $table) {
        $tableName = $table->$key;
        $rowCount = DB::table($tableName)->count();
        
        $tableData[] = [
            $tableName,
            $rowCount,
            $this->getTableSize($tableName)
        ];
    }
    
    $this->table(
        ['Table', 'Rows', 'Size'],
        $tableData
    );
}

protected function getTableSize($table)
{
    $result = DB::select("
        SELECT 
            ROUND(((data_length + index_length) / 1024 / 1024), 2) AS size_mb
        FROM information_schema.TABLES 
        WHERE table_schema = DATABASE()
        AND table_name = ?
    ", [$table]);
    
    return ($result[0]->size_mb ?? 0) . ' MB';
}

Output-nya akan seperti ini:

Database: laravel_app

+------------------+-------+---------+
| Table            | Rows  | Size    |
+------------------+-------+---------+
| users            | 1250  | 2.45 MB |
| orders           | 8430  | 15.2 MB |
| products         | 450   | 1.10 MB |
+------------------+-------+---------+

Step 4: Implementasi Method showTableSchema

Method ini menampilkan detail kolom dari satu tabel:

protected function showTableSchema($table)
{
    if (!Schema::hasTable($table)) {
        $this->error("Table '{$table}' does not exist.");
        return;
    }
    
    $this->info("Table: {$table}");
    $this->newLine();
    
    $columns = DB::select("
        SELECT 
            COLUMN_NAME,
            COLUMN_TYPE,
            IS_NULLABLE,
            COLUMN_KEY,
            COLUMN_DEFAULT,
            EXTRA
        FROM information_schema.COLUMNS
        WHERE TABLE_SCHEMA = DATABASE()
        AND TABLE_NAME = ?
        ORDER BY ORDINAL_POSITION
    ", [$table]);
    
    $columnData = [];
    
    foreach ($columns as $column) {
        $columnData[] = [
            $column->COLUMN_NAME,
            $column->COLUMN_TYPE,
            $column->IS_NULLABLE === 'YES' ? 'NULL' : 'NOT NULL',
            $column->COLUMN_KEY ?: '-',
            $column->COLUMN_DEFAULT ?? '-',
            $column->EXTRA ?: '-'
        ];
    }
    
    $this->table(
        ['Column', 'Type', 'Null', 'Key', 'Default', 'Extra'],
        $columnData
    );
    
    $this->showIndexes($table);
    $this->showForeignKeys($table);
}

Step 5: Tampilkan Index dan Foreign Keys

protected function showIndexes($table)
{
    $indexes = DB::select("SHOW INDEXES FROM {$table}");
    
    if (empty($indexes)) {
        return;
    }
    
    $this->newLine();
    $this->info("Indexes:");
    
    $indexData = [];
    $processedIndexes = [];
    
    foreach ($indexes as $index) {
        if (in_array($index->Key_name, $processedIndexes)) {
            continue;
        }
        
        $indexData[] = [
            $index->Key_name,
            $index->Non_unique ? 'NO' : 'YES',
            $index->Column_name
        ];
        
        $processedIndexes[] = $index->Key_name;
    }
    
    $this->table(
        ['Name', 'Unique', 'Column'],
        $indexData
    );
}

protected function showForeignKeys($table)
{
    $foreignKeys = DB::select("
        SELECT 
            CONSTRAINT_NAME,
            COLUMN_NAME,
            REFERENCED_TABLE_NAME,
            REFERENCED_COLUMN_NAME
        FROM information_schema.KEY_COLUMN_USAGE
        WHERE TABLE_SCHEMA = DATABASE()
        AND TABLE_NAME = ?
        AND REFERENCED_TABLE_NAME IS NOT NULL
    ", [$table]);
    
    if (empty($foreignKeys)) {
        return;
    }
    
    $this->newLine();
    $this->info("Foreign Keys:");
    
    $fkData = [];
    
    foreach ($foreignKeys as $fk) {
        $fkData[] = [
            $fk->CONSTRAINT_NAME,
            $fk->COLUMN_NAME,
            $fk->REFERENCED_TABLE_NAME . '(' . $fk->REFERENCED_COLUMN_NAME . ')'
        ];
    }
    
    $this->table(
        ['Constraint', 'Column', 'References'],
        $fkData
    );
}

Cara Pakai:

# Tampilkan semua tabel
php artisan schema:show

# Tampilkan detail tabel users
php artisan schema:show users

# Tampilkan detail tabel orders
php artisan schema:show orders

Output detail tabel:

Table: users

+------------+------------------+----------+-----+---------+-------------------+
| Column     | Type             | Null     | Key | Default | Extra             |
+------------+------------------+----------+-----+---------+-------------------+
| id         | bigint unsigned  | NOT NULL | PRI | -       | auto_increment    |
| name       | varchar(255)     | NOT NULL | -   | -       | -                 |
| email      | varchar(255)     | NOT NULL | UNI | -       | -                 |
| password   | varchar(255)     | NOT NULL | -   | -       | -                 |
| created_at | timestamp        | NULL     | -   | -       | -                 |
+------------+------------------+----------+-----+---------+-------------------+

Indexes:
+--------------+--------+--------+
| Name         | Unique | Column |
+--------------+--------+--------+
| PRIMARY      | YES    | id     |
| users_email  | YES    | email  |
+--------------+--------+--------+

Command ini sudah cukup powerful untuk inspeksi database sehari-hari.

Kesulitan dengan tugas programming atau butuh bantuan coding? KerjaKode siap membantu menyelesaikan tugas IT dan teknik informatika Anda. Dapatkan bantuan profesional di jasa tugas IT KerjaKode.

Alternatif Package Laravel Schema Viewer dan ERD Generator

Selain membuat command sendiri, ada beberapa package Laravel yang sudah mature untuk dokumentasi database.

1. Laravel Debugbar

Package barryvdh/laravel-debugbar punya tab Database yang menampilkan query dan struktur tabel.

Install:

composer require barryvdh/laravel-debugbar --dev

Setelah install, akses aplikasi Laravel kamu di browser. Debugbar akan muncul di bagian bawah dengan tab Database yang menampilkan semua query.

Kelebihan:

• Terintegrasi dengan development workflow
• Menampilkan query history dan execution time
• Bisa inspect query parameter

Kekurangan:

• Hanya bisa diakses lewat browser, bukan terminal
• Tidak menampilkan ERD atau relasi visual

2. Laravel ER Diagram Generator

Package beyondcode/laravel-er-diagram-generator menghasilkan ERD dalam format Graphviz.

Install:

composer require beyondcode/laravel-er-diagram-generator --dev

Generate diagram:

php artisan generate:erd output.png

Output berupa file PNG yang menampilkan relasi antar tabel secara visual.

Kelebihan:

• Visual representation yang jelas
• Otomatis detect foreign key relationships
• Support custom output format (PNG, SVG, PDF)

Kekurangan:

• Butuh Graphviz installed di server
• Tidak interactive, hanya static image

3. Laravel Schema Rules

Package laravie/schema menyediakan helper untuk inspeksi database schema secara programmatic.

Install:

composer require laravie/schema

Usage:

use Laravie\Schema\Schema;

$tables = Schema::tables();
$columns = Schema::columns('users');

Kelebihan:

• API yang clean dan Laravel-style
• Bisa diintegrasikan ke custom command atau test

Kekurangan:

• Tidak ada CLI command bawaan
• Harus coding manual untuk output

4. Laravel Schema Spy

Package mtolhuys/laravel-schema-spy adalah tools paling lengkap untuk inspeksi database Laravel.

Install:

composer require mtolhuys/laravel-schema-spy --dev

Publish config:

php artisan vendor:publish --provider="Mtolhuys\LaravelSchemaSpy\SchemaSpyServiceProvider"

Generate documentation:

php artisan schema:spy

Output berupa HTML documentation yang bisa dibuka di browser.

Kelebihan:

• Generate HTML documentation yang comprehensive
• Menampilkan table size, row count, indexes, foreign keys
• Bisa export ke berbagai format

Kekurangan:

• Setup awal agak kompleks
• File output besar jika database banyak tabel

Rekomendasi Terbaik

Untuk inspeksi cepat di terminal: buat custom command seperti yang sudah dijelaskan di atas.

Untuk dokumentasi tim yang persistent: gunakan beyondcode/laravel-er-diagram-generator atau mtolhuys/laravel-schema-spy.

Untuk debugging query di development: gunakan barryvdh/laravel-debugbar.

Tips Dokumentasi Database yang Bertahan Lama untuk Tim Remote

Custom command dan package memang membantu, tapi dokumentasi database tetap harus dijaga agar tidak outdated.

1. Migration Wajib Disertai Comment

Setiap migration file harus punya comment yang jelas:

Schema::create('orders', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained(); // FK ke users table
    $table->string('order_number')->unique()->comment('Format: ORD-YYYYMMDD-XXX');
    $table->decimal('total_amount', 10, 2)->comment('Total setelah diskon');
    $table->enum('status', ['pending', 'paid', 'shipped', 'completed'])->default('pending');
    $table->timestamps();
});

Comment ini akan muncul di database schema dan bisa dibaca oleh tools documentation.

2. Buat README.md untuk Database Schema

Buat file docs/database.md yang menjelaskan high-level architecture:

# Database Schema

## Core Tables

### users
Menyimpan data user aplikasi (customer dan admin).

Foreign Keys:
- Tidak ada

Related Tables:
- orders (one-to-many)
- addresses (one-to-many)

### orders
Menyimpan data transaksi pembelian.

Foreign Keys:
- user_id -> users.id

Related Tables:
- order_items (one-to-many)
- payments (one-to-one)

File ini jadi single source of truth untuk developer baru.

3. Gunakan Database Documentation Generator

Integrate documentation generator ke CI/CD pipeline:

# .github/workflows/docs.yml
name: Generate Database Docs

on:
  push:
    branches: [main]
    paths:
      - 'database/migrations/**'

jobs:
  generate-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Setup PHP
        uses: shivammathur/setup-php@v2
      - name: Install Dependencies
        run: composer install
      - name: Generate ERD
        run: php artisan generate:erd docs/erd.png
      - name: Commit Documentation
        run: |
          git config user.name "GitHub Actions"
          git add docs/erd.png
          git commit -m "Update database documentation"
          git push

Setiap kali ada perubahan migration, dokumentasi otomatis ter-update.

4. Code Review untuk Migration

Jangan approve PR yang mengubah database tanpa:

• Migration file yang clear
• Comment di kolom penting
• Update dokumentasi jika ada perubahan struktur signifikan

5. Seed Data untuk Development

Buat seeder yang representatif agar developer baru bisa langsung testing:

php artisan db:seed --class=DevelopmentSeeder

Seeder ini harus mencakup:

• Sample users dengan berbagai role
• Sample orders dengan berbagai status
• Sample products dengan kategori lengkap

Developer baru bisa langsung lihat data flow tanpa harus input manual.

6. Database Migration Testing

Pastikan migration bisa rollback dengan benar:

php artisan migrate:fresh
php artisan migrate
php artisan migrate:rollback
php artisan migrate

Test ini harus pass sebelum merge ke main branch.

7. Dokumentasi Foreign Key Cascade Behavior

Jika ada foreign key dengan cascade delete atau update, dokumentasikan dengan jelas:

$table->foreignId('user_id')
    ->constrained()
    ->onDelete('cascade') // HATI-HATI: Delete user akan delete semua orders
    ->comment('FK to users - CASCADE DELETE');

Behavior ini harus dijelaskan di docs atau di comment migration.

Kesimpulan

Laravel memang tidak punya artisan schema:show bawaan, tapi solusinya ada banyak.

Kamu bisa membuat custom command sendiri dengan effort minimal, atau menggunakan package yang sudah mature.

Yang paling penting: dokumentasi database harus jadi bagian dari workflow development, bukan afterthought.

Tim yang punya dokumentasi database yang baik akan:

• Onboarding developer baru lebih cepat
• Mengurangi bug akibat misunderstanding struktur data
• Code review lebih efektif
• Scaling aplikasi lebih mudah

Mulai dari sekarang, jadikan dokumentasi database sebagai prioritas dalam project Laravel kamu.

Custom command schema:show yang kita buat tadi bisa jadi starting point yang baik. Tinggal sesuaikan dengan kebutuhan tim.

Selamat mendokumentasikan database!