pg_multitenant_schemas 0.2.3 → 0.3.6

data/lib/pg_multitenant_schemas/configuration.rb

@@ -12,12 +12,18 @@ module PgMultitenantSchemas
     def initialize
       @tenant_model_class = "Tenant"
       @default_schema = "public"
+      # Enable development fallback with cookie support by default in development
       @development_fallback = false
+      begin
+        @development_fallback = ::Rails.env&.development? == true if defined?(::Rails)
+      rescue StandardError
+        # If Rails is not available, keep default
+      end
       @excluded_subdomains = %w[www api admin mail ftp blog support help docs staging]
       @common_tlds = %w[com org net edu gov mil int co uk ca au de fr jp cn dev test]
       @auto_create_schemas = true
       @connection_class = "ApplicationRecord"
-      @logger = defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : nil
+      @logger = defined?(::Rails) && ::Rails.respond_to?(:logger) ? ::Rails.logger : nil
     end
 
     def tenant_model

data/lib/pg_multitenant_schemas/context.rb

@@ -2,36 +2,90 @@
 
 module PgMultitenantSchemas
   # Thread-safe tenant context management
+  #
+  # The Context class manages the current tenant and schema in a thread-safe manner
+  # using Thread.current storage. This ensures proper isolation in multi-threaded
+  # environments like Rails servers.
+  #
+  # @example Get current schema
+  #   PgMultitenantSchemas::Context.current_schema #=> "tenant_123"
+  #
+  # @example Switch to tenant context
+  #   tenant = Tenant.find(1)
+  #   PgMultitenantSchemas::Context.switch_to_tenant(tenant)
+  #
+  # @example Use block-based context
+  #   PgMultitenantSchemas::Context.with_tenant(tenant) do
+  #     User.all  # Queries tenant's schema
+  #   end
   class Context
     class << self
+      # Get the current tenant object
+      #
+      # @return [Object, nil] The current tenant or nil if no tenant context is set
       def current_tenant
         Thread.current[:pg_multitenant_current_tenant]
       end
 
+      # Set the current tenant object
+      #
+      # @param tenant [Object] The tenant object to set as current
+      # @return [Object] The tenant object
       def current_tenant=(tenant)
         Thread.current[:pg_multitenant_current_tenant] = tenant
       end
 
+      # Get the current tenant schema name
+      #
+      # @return [String] The current schema name or default schema if not set
+      # @example
+      #   PgMultitenantSchemas::Context.current_schema #=> "tenant_123"
       def current_schema
         Thread.current[:pg_multitenant_current_schema] || PgMultitenantSchemas.configuration.default_schema
       end
 
+      # Set the current tenant schema name
+      #
+      # @param schema_name [String] The schema name to set as current
+      # @return [String] The schema name
       def current_schema=(schema_name)
         Thread.current[:pg_multitenant_current_schema] = schema_name
       end
 
+      # Reset the current tenant context to default
+      #
+      # Clears both tenant and schema context and restores the default schema
+      #
+      # @return [void]
+      # @example
+      #   PgMultitenantSchemas::Context.reset!
       def reset!
         Thread.current[:pg_multitenant_current_tenant] = nil
         Thread.current[:pg_multitenant_current_schema] = nil
         switch_to_schema(PgMultitenantSchemas.configuration.default_schema)
       end
 
+      # Switch to a specific schema
+      #
+      # @param schema_name [String] The schema name to switch to
+      # @return [void]
+      # @example
+      #   PgMultitenantSchemas::Context.switch_to_schema('tenant_123')
       def switch_to_schema(schema_name)
         schema_name = PgMultitenantSchemas.configuration.default_schema if schema_name.blank?
         SchemaSwitcher.switch_schema(schema_name)
         self.current_schema = schema_name
       end
 
+      # Switch to a specific tenant's schema
+      #
+      # @param tenant [Object, String] The tenant object (must respond to :subdomain) or schema name
+      # @return [void]
+      # @example With tenant object
+      #   tenant = Tenant.find(1)
+      #   PgMultitenantSchemas::Context.switch_to_tenant(tenant)
+      # @example With schema name
+      #   PgMultitenantSchemas::Context.switch_to_tenant('tenant_123')
       def switch_to_tenant(tenant)
         if tenant
           schema_name = tenant.respond_to?(:subdomain) ? tenant.subdomain : tenant.to_s
@@ -43,7 +97,23 @@ module PgMultitenantSchemas
         end
       end
 
-      # Execute block within tenant context
+      # Execute a block within a tenant context
+      #
+      # All database queries within the block will be executed in the tenant's schema.
+      # The previous context is restored after the block completes, even if an error occurs.
+      #
+      # @param tenant_or_schema [Object, String] The tenant object or schema name
+      # @yield Executes the given block in the tenant's schema context
+      # @return [Object] The return value of the block
+      # @example With tenant object
+      #   tenant = Tenant.find(1)
+      #   PgMultitenantSchemas::Context.with_tenant(tenant) do
+      #     User.all  # Queries tenant's schema
+      #   end
+      # @example With schema name
+      #   PgMultitenantSchemas::Context.with_tenant('tenant_123') do
+      #     Order.create!(status: 'pending')
+      #   end
       def with_tenant(tenant_or_schema)
         schema_name, tenant = extract_schema_and_tenant(tenant_or_schema)
         previous_tenant = current_tenant
@@ -82,7 +152,16 @@ module PgMultitenantSchemas
 
       public
 
-      # Create new tenant schema
+      # Create a new PostgreSQL schema for a tenant
+      #
+      # @param tenant_or_schema [Object, String] The tenant object or schema name
+      # @return [void]
+      # @raise [ArgumentError] if schema name is blank
+      # @example With tenant object
+      #   tenant = Tenant.create!(subdomain: 'acme')
+      #   PgMultitenantSchemas::Context.create_tenant_schema(tenant)
+      # @example With schema name
+      #   PgMultitenantSchemas::Context.create_tenant_schema('tenant_123')
       def create_tenant_schema(tenant_or_schema)
         schema_name = if tenant_or_schema.respond_to?(:subdomain)
                         tenant_or_schema.subdomain
@@ -92,7 +171,17 @@ module PgMultitenantSchemas
         SchemaSwitcher.create_schema(schema_name)
       end
 
-      # Drop tenant schema
+      # Drop a PostgreSQL schema for a tenant
+      #
+      # @param tenant_or_schema [Object, String] The tenant object or schema name
+      # @param cascade [Boolean] Whether to drop dependent objects (default: true)
+      # @return [void]
+      # @raise [ArgumentError] if schema name is blank
+      # @example With tenant object
+      #   tenant = Tenant.find(1)
+      #   PgMultitenantSchemas::Context.drop_tenant_schema(tenant)
+      # @example With cascade option
+      #   PgMultitenantSchemas::Context.drop_tenant_schema('old_tenant', cascade: true)
       def drop_tenant_schema(tenant_or_schema, cascade: true)
         schema_name = if tenant_or_schema.respond_to?(:subdomain)
                         tenant_or_schema.subdomain

data/lib/pg_multitenant_schemas/rails/controller_concern.rb

@@ -30,18 +30,93 @@ module PgMultitenantSchemas
       end
 
       def resolve_tenant_context
-        tenant = PgMultitenantSchemas::TenantResolver.resolve_tenant_with_fallback(request)
+        # Try to resolve tenant from cookie/session first (for development mode)
+        tenant = resolve_from_cookie_fallback(request)
+
+        # If no tenant from cookie/session, use normal resolution
+        tenant = PgMultitenantSchemas::TenantResolver.resolve_tenant_with_fallback(request) if tenant.nil?
+
         switch_to_tenant(tenant)
       rescue StandardError => e
         handle_tenant_resolution_error(e)
       end
 
+      private
+
+      # Try to resolve tenant from cookie/session-based schema (if available)
+      def resolve_from_cookie_fallback(request)
+        return nil unless should_use_cookie_fallback?
+
+        schema = extract_schema_from_request(request)
+        return nil unless schema.present? && PgMultitenantSchemas::SchemaSwitcher.schema_exists?(schema)
+
+        PgMultitenantSchemas::Context.current_schema = schema
+        @current_tenant = nil
+        VirtualTenant.new(schema)
+      rescue StandardError => e
+        ::Rails.logger.debug "PgMultitenantSchemas: resolve_from_cookie_fallback failed: #{e.class} #{e.message}"
+        nil
+      end
+
+      # Extract schema from session or cookies
+      def extract_schema_from_request(request)
+        # Try session first (most reliable)
+        if respond_to?(:session) && session.present? && session[:pg_multitenant_selected_schema].present?
+          return session[:pg_multitenant_selected_schema]
+        end
+
+        # Try various cookie sources
+        extract_schema_from_cookies(request)
+      end
+
+      # Extract schema from multiple cookie sources
+      def extract_schema_from_cookies(request)
+        if request.respond_to?(:cookie_jar)
+          request.cookie_jar[:pg_multitenant_selected_schema]
+        elsif request.respond_to?(:cookies)
+          request.cookies[:pg_multitenant_selected_schema]
+        elsif respond_to?(:cookies)
+          cookies[:pg_multitenant_selected_schema]
+        else
+          extract_schema_from_cookie_header(request)
+        end
+      end
+
+      # Parse schema from raw HTTP_COOKIE header
+      def extract_schema_from_cookie_header(request)
+        cookie_header = request.env["HTTP_COOKIE"]
+        return nil unless cookie_header.present?
+
+        # Parse "key1=value1; key2=value2; ..." format
+        cookie_header.split("; ").find do |c|
+          c.start_with?("pg_multitenant_selected_schema=")
+        end&.split("=")&.last
+      end
+
+      # Virtual tenant object for cookie-based schema resolution
+      class VirtualTenant
+        attr_reader :subdomain, :schema
+
+        def initialize(schema)
+          @subdomain = schema
+          @schema = schema
+        end
+      end
+
+      # Check if we should try cookie-based resolution
+      def should_use_cookie_fallback?
+        return false unless PgMultitenantSchemas.configuration.development_fallback
+        return false unless ::Rails.env.development?
+
+        # If we reach here, we should attempt cookie-based resolution
+        true
+      end
+
       def reset_tenant_context
         @current_tenant = nil
         PgMultitenantSchemas::Context.reset!
-      rescue StandardError => e
-        Rails.logger.error "PgMultitenantSchemas: Failed to reset tenant context: #{e.message}"
-        # Don't raise - this is cleanup code
+      rescue StandardError
+        # Silently ignore errors during context reset
       end
 
       protected
@@ -53,9 +128,9 @@ module PgMultitenantSchemas
 
       # Override this method to customize error handling
       def handle_tenant_resolution_error(error)
-        Rails.logger.error "PgMultitenantSchemas: Tenant resolution failed: #{error.message}"
+        ::Rails.logger.error "PgMultitenantSchemas: Tenant resolution failed: #{error.message}"
 
-        raise error unless PgMultitenantSchemas.configuration.development_fallback && Rails.env.development?
+        raise error unless PgMultitenantSchemas.configuration.development_fallback && ::Rails.env.development?
 
         switch_to_tenant(nil) # Fall back to default schema in development
       end

data/lib/pg_multitenant_schemas/rails/generators/install_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module PgMultitenantSchemas
+  module Generators
+    # Generates the initializer used to configure PgMultitenantSchemas in a Rails app.
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a PgMultitenantSchemas initializer in your Rails app"
+
+      def create_initializer
+        create_file "config/initializers/pg_multitenant_schemas.rb", <<~RUBY
+          PgMultitenantSchemas.configure do |config|
+            config.connection_class = "ApplicationRecord"
+            config.tenant_model_class = "Tenant"
+            config.default_schema = "public"
+            config.excluded_subdomains = ["www", "api", "admin"]
+            config.development_fallback = true
+            config.auto_create_schemas = true
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/pg_multitenant_schemas/rails/generators/tenant_migration_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module PgMultitenantSchemas
+  module Generators
+    # Generates a migration for adding a tenant to a schema.
+    class TenantMigrationGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a migration to add a tenant to a schema"
+
+      argument :tenant_name, type: :string, banner: "TENANT_NAME"
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def create_migration
+        migration_template(
+          "tenant_migration.rb.erb",
+          "db/migrate/create_#{tenant_name}_schema.rb"
+        )
+      end
+    end
+  end
+end

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,6 +12,33 @@ 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 all task files

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,7 +129,12 @@ 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()")
@@ -81,6 +142,11 @@ module PgMultitenantSchemas
       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)

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; }