pg_multitenant_schemas 0.2.2 → 0.3.6

data/lib/pg_multitenant_schemas/rails/model_concern.rb

@@ -62,18 +62,18 @@ module PgMultitenantSchemas
 
       # Log schema operations
       def log_schema_operation(message)
-        Rails.logger.info "PgMultitenantSchemas: #{message}"
+        ::Rails.logger.info "PgMultitenantSchemas: #{message}"
       end
 
       # Handle schema operation errors
       def handle_schema_error(error, operation)
-        Rails.logger.error "PgMultitenantSchemas: Failed to #{operation} schema '#{subdomain}': #{error.message}"
+        ::Rails.logger.error "PgMultitenantSchemas: Failed to #{operation} schema '#{subdomain}': #{error.message}"
         raise error unless development_fallback_enabled?
       end
 
       # Check if development fallback is enabled
       def development_fallback_enabled?
-        PgMultitenantSchemas.configuration.development_fallback && Rails.env.development?
+        PgMultitenantSchemas.configuration.development_fallback && ::Rails.env.development?
       end
 
       class_methods do

data/lib/pg_multitenant_schemas/rails/railtie.rb

@@ -12,9 +12,39 @@ module PgMultitenantSchemas
         end
       end
 
+      initializer "pg_multitenant_schemas.middleware" do |app|
+        # Add cookies middleware for API-only apps in development
+        # Needed for cookie-based schema switching between dashboard and main app
+        if ::Rails.env.development?
+          # Insert cookies middleware at the beginning
+          app.config.middleware.insert_before 0, ActionDispatch::Cookies
+          # Session store for reading cookies properly
+          app.config.middleware.insert_before 1, ActionDispatch::Session::CookieStore,
+                                              key: "_pg_multitenant_session"
+          # Flash support for notices/alerts
+          app.config.middleware.insert_before 2, ActionDispatch::Flash
+        end
+      end
+
+      initializer "pg_multitenant_schemas.controller_integration" do
+        # Automatically extend ApplicationController with ControllerConcern
+        ActiveSupport.on_load(:action_controller) do
+          include PgMultitenantSchemas::Rails::ControllerConcern
+        end
+      end
+
+      initializer "pg_multitenant_schemas.ui.routes" do |app|
+        app.routes.append do
+          mount PgMultitenantSchemas::UI::Engine, at: "/pg_multitenant_schemas"
+        end
+      end
+
       # Add rake tasks
       rake_tasks do
-        load File.expand_path("../tasks/pg_multitenant_schemas.rake", __dir__)
+        # Load all task files
+        Dir[File.expand_path("../tasks/*.rake", __dir__)].each do |task_file|
+          load task_file
+        end
       end
 
       # Add generators

data/lib/pg_multitenant_schemas/schema_switcher.rb

@@ -1,16 +1,36 @@
 # frozen_string_literal: true
 
 module PgMultitenantSchemas
-  # Core schema switching functionality
+  # Low-level PostgreSQL schema switching and management
+  #
+  # The SchemaSwitcher class provides direct access to PostgreSQL schema operations.
+  # It handles both Rails and raw PG connections transparently.
+  #
+  # @example Switching schemas
+  #   PgMultitenantSchemas::SchemaSwitcher.switch_schema('tenant_123')
+  #
+  # @example Creating a schema
+  #   PgMultitenantSchemas::SchemaSwitcher.create_schema('new_tenant')
+  #
+  # @example Listing all schemas
+  #   PgMultitenantSchemas::SchemaSwitcher.list_schemas
+  #   #=> ["public", "tenant_123", "tenant_456"]
   class SchemaSwitcher
     class << self
       # Initialize connection management
+      #
+      # Called by the Railtie when Rails starts. No special initialization needed.
+      #
+      # @return [void]
       def initialize_connection
         # This is called by the Railtie when Rails starts
         # No special initialization needed as we use the configured connection class
       end
 
       # Get the database connection from the configured connection class
+      #
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter, PG::Connection]
+      # @raise [PgMultitenantSchemas::ConnectionError] if connection cannot be established
       def connection
         connection_class = PgMultitenantSchemas.configuration.connection_class
         if connection_class.is_a?(String)
@@ -22,7 +42,15 @@ module PgMultitenantSchemas
         raise ConnectionError, "Failed to get database connection: #{e.message}"
       end
 
-      # Switches the search_path to the specified schema
+      # Switch the current PostgreSQL schema
+      #
+      # Sets the search_path to the specified schema using SET search_path.
+      #
+      # @param schema_name [String] The schema name to switch to
+      # @return [void]
+      # @raise [ArgumentError] if schema name is blank
+      # @example
+      #   PgMultitenantSchemas::SchemaSwitcher.switch_schema('tenant_123')
       def switch_schema(schema_name)
         raise ArgumentError, "Schema name cannot be empty" if schema_name.nil? || schema_name.strip.empty?
 
@@ -31,13 +59,25 @@ module PgMultitenantSchemas
         execute_sql(conn, "SET search_path TO #{quoted_schema};")
       end
 
-      # Reset to default schema
+      # Reset to the default PostgreSQL schema
+      #
+      # Sets search_path back to 'public'.
+      #
+      # @return [void]
       def reset_schema
         conn = connection
         execute_sql(conn, "SET search_path TO public;")
       end
 
-      # Create a new schema
+      # Create a new PostgreSQL schema
+      #
+      # Uses CREATE SCHEMA IF NOT EXISTS for idempotency.
+      #
+      # @param schema_name [String] The schema name to create
+      # @return [void]
+      # @raise [ArgumentError] if schema name is blank
+      # @example
+      #   PgMultitenantSchemas::SchemaSwitcher.create_schema('tenant_123')
       def create_schema(schema_name)
         raise ArgumentError, "Schema name cannot be empty" if schema_name.nil? || schema_name.strip.empty?
 
@@ -46,7 +86,16 @@ module PgMultitenantSchemas
         execute_sql(conn, "CREATE SCHEMA IF NOT EXISTS #{quoted_schema};")
       end
 
-      # Drop a schema
+      # Drop a PostgreSQL schema
+      #
+      # @param schema_name [String] The schema name to drop
+      # @param cascade [Boolean] Whether to drop dependent objects (default: true)
+      # @return [void]
+      # @raise [ArgumentError] if schema name is blank
+      # @example
+      #   PgMultitenantSchemas::SchemaSwitcher.drop_schema('old_tenant')
+      # @example With CASCADE option
+      #   PgMultitenantSchemas::SchemaSwitcher.drop_schema('old_tenant', cascade: true)
       def drop_schema(schema_name, cascade: true)
         raise ArgumentError, "Schema name cannot be empty" if schema_name.nil? || schema_name.strip.empty?
 
@@ -56,7 +105,14 @@ module PgMultitenantSchemas
         execute_sql(conn, "DROP SCHEMA IF EXISTS #{quoted_schema} #{cascade_option};")
       end
 
-      # Check if schema exists
+      # Check if a schema exists in the database
+      #
+      # @param schema_name [String] The schema name to check
+      # @return [Boolean] true if the schema exists, false otherwise
+      # @example
+      #   if PgMultitenantSchemas::SchemaSwitcher.schema_exists?('tenant_123')
+      #     # Schema exists
+      #   end
       def schema_exists?(schema_name)
         return false if schema_name.nil? || schema_name.strip.empty?
 
@@ -73,15 +129,59 @@ module PgMultitenantSchemas
         [true, "t", "true"].include?(value)
       end
 
-      # Get current schema
+      # Get the current PostgreSQL schema
+      #
+      # @return [String] The current schema name
+      # @example
+      #   PgMultitenantSchemas::SchemaSwitcher.current_schema
+      #   #=> "tenant_123"
       def current_schema
         conn = connection
         result = execute_sql(conn, "SELECT current_schema()")
         get_result_value(result, 0, 0)
       end
 
+      # List all schemas in the database
+      #
+      # @return [Array<String>] Array of schema names
+      # @example
+      #   PgMultitenantSchemas::SchemaSwitcher.list_schemas
+      #   #=> ["public", "tenant_123", "tenant_456"]
+      def list_schemas
+        conn = connection
+        result = execute_sql(conn, <<~SQL)
+          SELECT schema_name FROM information_schema.schemata#{" "}
+          ORDER BY schema_name
+        SQL
+
+        extract_schemas_from_result(result)
+      end
+
       private
 
+      def extract_schemas_from_result(result)
+        schemas = []
+
+        if result.respond_to?(:rows)
+          # Rails ActiveRecord::Result
+          result.rows.each { |row| schemas << row[0] }
+        elsif result.respond_to?(:each)
+          # Raw PG::Result
+          result.each { |row| schemas << row["schema_name"] }
+        else
+          # Fallback for other result types
+          extract_schemas_fallback(result, schemas)
+        end
+
+        schemas
+      end
+
+      def extract_schemas_fallback(result, schemas)
+        (0...result.ntuples).each do |i|
+          schemas << get_result_value(result, i, 0)
+        end
+      end
+
       # Execute SQL - handles both Rails connections and raw PG connections
       def execute_sql(conn, sql)
         if conn.respond_to?(:execute)

data/lib/pg_multitenant_schemas/tasks/tenant_tasks.rake

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# Load individual task files
-Dir[File.join(File.dirname(__FILE__), "*.rake")].each { |file| load file unless file == __FILE__ }
-
 require_relative "../tenant_task_helpers"
 
 namespace :tenants do

data/lib/pg_multitenant_schemas/tenant_resolver.rb

@@ -63,7 +63,7 @@ module PgMultitenantSchemas
           tenant_model.find_by(subdomain: subdomain, status: "active")
         end
       rescue StandardError => e
-        Rails.logger.error "PgMultitenantSchemas: Error finding tenant '#{subdomain}': #{e.message}"
+        ::Rails.logger.error "PgMultitenantSchemas: Error finding tenant '#{subdomain}': #{e.message}"
         nil
       end
 
@@ -80,8 +80,8 @@ module PgMultitenantSchemas
         tenant = resolve_tenant_from_request(request)
 
         # If no tenant found and development fallback is enabled
-        if tenant.nil? && PgMultitenantSchemas.configuration.development_fallback && Rails.env.development?
-          Rails.logger.info "PgMultitenantSchemas: No tenant found, using development fallback"
+        if tenant.nil? && PgMultitenantSchemas.configuration.development_fallback && ::Rails.env.development?
+          ::Rails.logger.info "PgMultitenantSchemas: No tenant found, using development fallback"
           return nil # This will cause switch to default schema
         end
 

data/lib/pg_multitenant_schemas/ui/app/assets/stylesheets/pg_multitenant_schemas/ui/application.css

@@ -0,0 +1,94 @@
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  background: #f5f5f5;
+  color: #1a1a1a;
+  min-height: 100vh;
+}
+
+header {
+  background: #1e293b;
+  color: #fff;
+  padding: 0 1.5rem;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  height: 56px;
+  box-shadow: 0 1px 4px rgba(0,0,0,.3);
+}
+header h1 { font-size: 1rem; font-weight: 600; letter-spacing: .03em; }
+header span { font-size: .75rem; color: #94a3b8; }
+
+main { max-width: 960px; margin: 2rem auto; padding: 0 1rem; }
+
+.flash { padding: .75rem 1rem; border-radius: 6px; margin-bottom: 1.25rem; font-size: .875rem; }
+.flash.notice { background: #dcfce7; color: #166534; border: 1px solid #bbf7d0; }
+.flash.alert  { background: #fee2e2; color: #991b1b; border: 1px solid #fecaca; }
+
+.card { background: #fff; border-radius: 8px; box-shadow: 0 1px 3px rgba(0,0,0,.1); }
+.card-header {
+  padding: 1rem 1.25rem;
+  border-bottom: 1px solid #e5e7eb;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+.card-header h2 { font-size: 1rem; font-weight: 600; }
+
+table { width: 100%; border-collapse: collapse; font-size: .875rem; }
+th, td { padding: .65rem 1.25rem; text-align: left; }
+th { font-weight: 600; color: #6b7280; font-size: .75rem; text-transform: uppercase; letter-spacing: .05em; background: #f9fafb; border-bottom: 1px solid #e5e7eb; }
+tr:not(:last-child) td { border-bottom: 1px solid #f3f4f6; }
+tr:hover td { background: #fafafa; }
+
+.badge {
+  display: inline-flex; align-items: center; gap: .3rem;
+  padding: .2rem .55rem; border-radius: 999px; font-size: .7rem; font-weight: 600;
+}
+.badge-green  { background: #dcfce7; color: #166534; }
+.badge-yellow { background: #fef9c3; color: #854d0e; }
+.badge-red    { background: #fee2e2; color: #991b1b; }
+.badge-gray   { background: #f3f4f6; color: #6b7280; }
+
+.btn {
+  display: inline-flex; align-items: center; gap: .35rem;
+  padding: .45rem .9rem; border-radius: 6px; font-size: .8rem; font-weight: 500;
+  text-decoration: none; border: none; cursor: pointer; transition: filter .15s;
+}
+.btn:hover { filter: brightness(.92); }
+.btn-primary  { background: #3b82f6; color: #fff; }
+.btn-green    { background: #22c55e; color: #fff; }
+.btn-yellow   { background: #f59e0b; color: #fff; }
+.btn-red      { background: #ef4444; color: #fff; }
+.btn-ghost    { background: #f3f4f6; color: #374151; }
+.btn-sm       { padding: .3rem .65rem; font-size: .75rem; }
+
+.actions { display: flex; gap: .4rem; flex-wrap: wrap; }
+.toolbar  { display: flex; gap: .6rem; align-items: center; flex-wrap: wrap; }
+
+.schema-badge {
+  font-family: monospace; font-size: .78rem;
+  background: #eff6ff; color: #1d4ed8;
+  padding: .15rem .45rem; border-radius: 4px;
+}
+
+form.inline { display: inline; }
+
+/* switch bar */
+.switch-bar {
+  margin-bottom: 1.5rem;
+  background: #fff;
+  border: 1px solid #e5e7eb;
+  border-radius: 8px;
+  padding: .75rem 1.25rem;
+  display: flex; align-items: center; gap: .75rem; font-size: .875rem; flex-wrap: wrap;
+}
+.switch-bar label { font-weight: 500; color: #374151; }
+.switch-bar select {
+  flex: 1; min-width: 160px; max-width: 280px;
+  border: 1px solid #d1d5db; border-radius: 6px;
+  padding: .35rem .6rem; font-size: .875rem;
+}
+
+.empty { padding: 2.5rem; text-align: center; color: #9ca3af; font-size: .9rem; }

data/lib/pg_multitenant_schemas/ui/app/controllers/pg_multitenant_schemas/ui/tenants_controller.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module PgMultitenantSchemas
+  module UI
+    # Controller backing the UI engine for listing and managing tenants and schemas.
+    class TenantsController < ActionController::Base
+      layout "pg_multitenant_schemas/ui/application"
+      skip_forgery_protection only: :destroy
+
+      before_action :load_tenant_model
+
+      def index
+        @tenants = tenant_model.all.order(:subdomain)
+        @schemas = load_available_schemas
+        @current_schema = resolve_selected_schema
+      end
+
+      def new
+        @tenant = tenant_model.new
+      end
+
+      def create
+        @tenant = tenant_model.new(tenant_params)
+
+        if @tenant.save
+          PgMultitenantSchemas::Migrator.setup_tenant(@tenant.subdomain, verbose: false)
+          redirect_to "/pg_multitenant_schemas/tenants",
+                      notice: "Tenant '#{@tenant.subdomain}' created and schema provisioned."
+        else
+          render :new, status: :unprocessable_entity
+        end
+      rescue StandardError => e
+        @tenant&.destroy if @tenant&.persisted?
+        redirect_to "/pg_multitenant_schemas/tenants",
+                    alert: "Failed to provision schema: #{e.message}"
+      end
+
+      def destroy
+        @tenant = tenant_model.find(params[:id])
+        schema = @tenant.subdomain
+
+        @tenant.destroy
+        PgMultitenantSchemas::SchemaSwitcher.drop_schema(schema)
+        redirect_to "/pg_multitenant_schemas/tenants",
+                    notice: "Tenant '#{schema}' and its schema deleted."
+      rescue StandardError => e
+        redirect_to "/pg_multitenant_schemas/tenants",
+                    alert: "Error deleting tenant: #{e.message}"
+      end
+
+      def migrate
+        @tenant = tenant_model.find(params[:id])
+        result = PgMultitenantSchemas::Migrator.migrate_tenant(@tenant.subdomain, verbose: false)
+        status = result[:status] == :success ? "notice" : "alert"
+        msg = result[:message] || "Migration completed."
+        redirect_to "/pg_multitenant_schemas/tenants", status => msg
+      rescue StandardError => e
+        redirect_to "/pg_multitenant_schemas/tenants", alert: "Migration failed: #{e.message}"
+      end
+
+      def migrate_all
+        results = PgMultitenantSchemas::Migrator.migrate_all(verbose: false)
+        failed = results.count { |r| r[:status] == :error }
+        if failed.zero?
+          redirect_to "/pg_multitenant_schemas/tenants",
+                      notice: "All #{results.size} tenant schemas migrated successfully."
+        else
+          redirect_to "/pg_multitenant_schemas/tenants",
+                      alert: "#{failed} of #{results.size} migrations failed."
+        end
+      end
+
+      def migration_status
+        @tenant = tenant_model.find(params[:id])
+        statuses = PgMultitenantSchemas::Migrator.migration_status(verbose: false)
+        @status = statuses.find { |s| s[:schema] == @tenant.subdomain } || {}
+        render :migration_status
+      end
+
+      def switch
+        schema = params[:schema].to_s.strip
+        return redirect_invalid_schema(schema) unless PgMultitenantSchemas::SchemaSwitcher.schema_exists?(schema)
+
+        PgMultitenantSchemas::Context.current_schema = schema
+        store_schema_in_session_and_cookies(schema)
+        redirect_to "/pg_multitenant_schemas/tenants",
+                    notice: "Switched active context to schema '#{schema}'."
+      end
+
+      private
+
+      def load_available_schemas
+        PgMultitenantSchemas::SchemaSwitcher.list_schemas
+      rescue StandardError
+        []
+      end
+
+      def resolve_selected_schema
+        selected = (session[:pg_multitenant_selected_schema] || cookies[:pg_multitenant_selected_schema]).to_s.strip
+        return selected if selected.present? && load_available_schemas.include?(selected)
+
+        PgMultitenantSchemas::Context.current_schema
+      end
+
+      def store_schema_in_session_and_cookies(schema)
+        session[:pg_multitenant_selected_schema] = schema
+        cookies[:pg_multitenant_selected_schema] = {
+          value: schema,
+          expires: 24.hours.from_now,
+          path: "/",
+          same_site: :lax,
+          http_only: false
+        }
+      end
+
+      def redirect_invalid_schema(schema)
+        redirect_to "/pg_multitenant_schemas/tenants",
+                    alert: "Schema '#{schema}' does not exist."
+      end
+
+      def load_tenant_model
+        @tenant_model_name = PgMultitenantSchemas.configuration.tenant_model_class
+      end
+
+      def tenant_model = @tenant_model_name.constantize
+
+      def tenant_params = params.require(:tenant).permit(:subdomain, :name, :status)
+    end
+  end
+end

data/lib/pg_multitenant_schemas/ui/app/views/layouts/pg_multitenant_schemas/ui/application.html.erb

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Tenant Manager · PgMultitenantSchemas</title>
+  <%= csrf_meta_tags %>
+  <style>
+    <%= File.read(File.expand_path("../../../../assets/stylesheets/pg_multitenant_schemas/ui/application.css", __dir__)).html_safe %>
+  </style>
+</head>
+<body>
+  <header>
+    <h1>🏢 Tenant Manager</h1>
+    <span>pg_multitenant_schemas</span>
+  </header>
+
+  <main>
+    <% if flash[:notice] %>
+      <div class="flash notice"><%= flash[:notice] %></div>
+    <% end %>
+    <% if flash[:alert] %>
+      <div class="flash alert"><%= flash[:alert] %></div>
+    <% end %>
+
+    <%= yield %>
+  </main>
+</body>
+</html>

data/lib/pg_multitenant_schemas/ui/app/views/pg_multitenant_schemas/ui/tenants/index.html.erb

@@ -0,0 +1,85 @@
+<%# Switch active schema context %>
+<div class="switch-bar">
+  <label>Active schema:</label>
+  <span class="schema-badge" id="current-schema-badge"><%= @current_schema %></span>
+
+  <%= form_with url: "/pg_multitenant_schemas/tenants/switch", method: :post, local: true do |f| %>
+    <%= f.select :schema,
+          options_for_select(@schemas, @current_schema),
+          { include_blank: false },
+          class: "",
+          id: "schema-select" %>
+    <%= f.submit "Switch →", class: "btn btn-ghost btn-sm" %>
+  <% end %>
+</div>
+
+<script>
+  // Update badge when selection changes
+  document.getElementById('schema-select')?.addEventListener('change', function(e) {
+    document.getElementById('current-schema-badge').textContent = e.target.value;
+  });
+</script>
+
+<%# Toolbar %>
+<div class="toolbar" style="margin-bottom:1rem;">
+  <%= link_to "＋ New Tenant", "/pg_multitenant_schemas/tenants/new", class: "btn btn-primary" %>
+
+  <%= form_with url: "/pg_multitenant_schemas/tenants/migrate_all", method: :post, local: true do |f| %>
+    <%= f.submit "⚡ Migrate All", class: "btn btn-yellow",
+          data: { confirm: "Run pending migrations on all tenant schemas?" } %>
+  <% end %>
+</div>
+
+<%# Tenant table %>
+<div class="card">
+  <div class="card-header">
+    <h2>Tenants <span style="font-weight:400;color:#9ca3af;">(<%= @tenants.count %>)</span></h2>
+  </div>
+
+  <% if @tenants.empty? %>
+    <div class="empty">No tenants yet. Create your first one above.</div>
+  <% else %>
+    <table>
+      <thead>
+        <tr>
+          <th>Subdomain</th>
+          <th>Name</th>
+          <th>Status</th>
+          <th>Actions</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @tenants.each do |tenant| %>
+          <tr>
+            <td><span class="schema-badge"><%= tenant.subdomain %></span></td>
+            <td><%= tenant.try(:name) || "—" %></td>
+            <td>
+              <% status = tenant.try(:status).to_s %>
+              <% badge_class = { "active" => "badge-green", "trial" => "badge-yellow",
+                                 "inactive" => "badge-gray", "suspended" => "badge-red" }[status] || "badge-gray" %>
+              <span class="badge <%= badge_class %>"><%= status.presence || "—" %></span>
+            </td>
+            <td>
+              <div class="actions">
+                <%= link_to "📊 Status",
+                      "/pg_multitenant_schemas/tenants/#{tenant.id}/migration_status",
+                      class: "btn btn-ghost btn-sm" %>
+
+                <%= form_with url: "/pg_multitenant_schemas/tenants/#{tenant.id}/migrate",
+                      method: :post, local: true, style: "display:inline" do |f| %>
+                  <%= f.submit "▶ Migrate", class: "btn btn-green btn-sm" %>
+                <% end %>
+
+                <%= form_with url: "/pg_multitenant_schemas/tenants/#{tenant.id}",
+                      method: :delete, local: true, style: "display:inline" do |f| %>
+                  <%= f.submit "✕ Delete", class: "btn btn-red btn-sm",
+                        data: { confirm: "Delete tenant '#{tenant.subdomain}' and drop its schema? This is irreversible." } %>
+                <% end %>
+              </div>
+            </td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  <% end %>
+</div>

data/lib/pg_multitenant_schemas/ui/app/views/pg_multitenant_schemas/ui/tenants/migration_status.html.erb

@@ -0,0 +1,45 @@
+<%= link_to "← Back to Tenants", "/pg_multitenant_schemas/tenants", class: "btn btn-ghost btn-sm", style: "margin-bottom:1rem;display:inline-flex;" %>
+
+<div class="card" style="max-width:560px;">
+  <div class="card-header">
+    <h2>Migration Status — <span class="schema-badge"><%= @tenant.subdomain %></span></h2>
+  </div>
+
+  <div style="padding:1.25rem;display:flex;flex-direction:column;gap:1rem;">
+    <% if @status[:error] %>
+      <div class="flash alert">Error: <%= @status[:error] %></div>
+    <% else %>
+      <table>
+        <tbody>
+          <tr>
+            <td style="color:#6b7280;font-size:.8rem;font-weight:600;text-transform:uppercase;">Status</td>
+            <td>
+              <% if @status[:status] == :up_to_date %>
+                <span class="badge badge-green">✓ Up to date</span>
+              <% elsif @status[:status] == :pending %>
+                <span class="badge badge-yellow">⚠ Pending</span>
+              <% else %>
+                <span class="badge badge-gray"><%= @status[:status] %></span>
+              <% end %>
+            </td>
+          </tr>
+          <tr>
+            <td style="color:#6b7280;font-size:.8rem;font-weight:600;text-transform:uppercase;">Applied</td>
+            <td><strong><%= @status[:applied_count] || 0 %></strong> migrations</td>
+          </tr>
+          <tr>
+            <td style="color:#6b7280;font-size:.8rem;font-weight:600;text-transform:uppercase;">Pending</td>
+            <td><strong><%= @status[:pending_count] || 0 %></strong> migrations</td>
+          </tr>
+        </tbody>
+      </table>
+
+      <% if @status[:status] == :pending %>
+        <%= form_with url: "/pg_multitenant_schemas/tenants/#{@tenant.id}/migrate",
+              method: :post, local: true do |f| %>
+          <%= f.submit "▶ Run Migrations Now", class: "btn btn-green" %>
+        <% end %>
+      <% end %>
+    <% end %>
+  </div>
+</div>