pg_multitenant_schemas 0.1.3 → 0.2.0

data/lib/pg_multitenant_schemas/migration_status_reporter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module PgMultitenantSchemas
+  # Migration status reporting functionality
+  module MigrationStatusReporter
+    # Check migration status across all tenants
+    def migration_status(verbose: true)
+      schemas = tenant_schemas
+      results = collect_migration_status_for_schemas(schemas)
+      display_status_report(results, verbose)
+      results
+    end
+
+    private
+
+    def collect_migration_status_for_schemas(schemas)
+      schemas.map do |schema|
+        collect_status_for_schema(schema)
+      end
+    end
+
+    def collect_status_for_schema(schema)
+      original_schema = current_schema
+
+      begin
+        switch_to_schema(schema)
+        build_schema_status(schema)
+      rescue StandardError => e
+        { schema: schema, error: e.message, status: :error }
+      ensure
+        switch_to_schema(original_schema) if original_schema
+      end
+    end
+
+    def build_schema_status(schema)
+      pending = pending_migrations
+      applied = applied_migrations
+
+      {
+        schema: schema,
+        pending_count: pending.count,
+        applied_count: applied.count,
+        status: pending.any? ? :pending : :up_to_date
+      }
+    end
+
+    def display_status_report(results, verbose)
+      return unless verbose
+
+      puts "📋 Migration Status Report:"
+      results.each { |result| display_schema_status(result) }
+    end
+
+    def display_schema_status(result)
+      case result[:status]
+      when :up_to_date
+        puts "  ✅ #{result[:schema]}: Up to date (#{result[:applied_count]} applied)"
+      when :pending
+        puts "  ⏳ #{result[:schema]}: #{result[:pending_count]} pending, #{result[:applied_count]} applied"
+      when :error
+        puts "  ❌ #{result[:schema]}: Error - #{result[:error]}"
+      end
+    end
+  end
+end

data/lib/pg_multitenant_schemas/migrator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "migration_status_reporter"
+require_relative "migration_schema_operations"
+require_relative "migration_executor"
+require_relative "migration_display_reporter"
+
+module PgMultitenantSchemas
+  # Enhanced migration management for multi-tenant schemas
+  # Provides automated migration operations across tenant schemas
+  class Migrator
+    extend MigrationStatusReporter
+    extend MigrationSchemaOperations
+    extend MigrationExecutor
+    extend MigrationDisplayReporter
+
+    class << self
+      # Run migrations on all tenant schemas
+      def migrate_all(verbose: true, ignore_errors: false)
+        schemas = tenant_schemas
+        results = process_schemas_migration(schemas, verbose, ignore_errors)
+
+        display_migration_summary(results, verbose)
+        results
+      end
+
+      # Run migrations on a specific tenant schema
+      def migrate_tenant(schema_name, verbose: true, raise_on_error: true)
+        return handle_missing_schema(schema_name, verbose, raise_on_error) unless schema_exists?(schema_name)
+
+        execute_tenant_migration(schema_name, verbose, raise_on_error)
+      end
+
+      # Setup tenant with schema creation and migrations
+      def setup_tenant(schema_name, verbose: true)
+        puts "🏗️  Setting up tenant: #{schema_name}" if verbose
+
+        begin
+          create_tenant_schema_if_needed(schema_name, verbose)
+          result = migrate_tenant(schema_name, verbose: verbose)
+          puts "  🎉 Tenant setup completed!" if verbose
+          result
+        rescue StandardError => e
+          puts "  ❌ Setup failed: #{e.message}" if verbose
+          raise
+        end
+      end
+
+      # Setup all tenants from Tenant model
+      def setup_all_tenants(verbose: true)
+        validate_tenant_model_exists
+        tenants = Tenant.all
+        puts "🏗️  Setting up #{tenants.count} tenants..." if verbose
+
+        results = process_setup_for_tenants(tenants, verbose)
+        display_setup_summary(results, verbose)
+        results
+      end
+
+      # Create a new tenant with schema and migrations
+      def create_tenant_with_schema(attributes, verbose: true)
+        validate_tenant_model_exists
+        tenant = Tenant.create!(attributes)
+        schema_name = extract_schema_name(tenant)
+
+        puts "🆕 Creating new tenant: #{schema_name}" if verbose
+        setup_tenant(schema_name, verbose: verbose)
+        tenant
+      end
+
+      # Rollback migrations for a specific tenant
+      def rollback_tenant(schema_name, steps: 1, verbose: true)
+        puts "⏪ Rolling back #{steps} steps for #{schema_name}" if verbose
+        original_schema = current_schema
+
+        begin
+          switch_to_schema(schema_name)
+          ActiveRecord::Base.connection.migration_context.rollback(migration_paths, steps)
+          puts "  ✅ Rollback completed" if verbose
+        rescue StandardError => e
+          puts "  ❌ Rollback failed: #{e.message}" if verbose
+          raise
+        ensure
+          switch_to_schema(original_schema) if original_schema
+        end
+      end
+    end
+  end
+end

data/lib/pg_multitenant_schemas/schema_switcher.rb

@@ -22,118 +22,92 @@ module PgMultitenantSchemas
         raise ConnectionError, "Failed to get database connection: #{e.message}"
       end
 
-      # Switches the search_path - supports both APIs for backward compatibility
-      def switch_schema(conn_or_schema, schema = nil)
-        if conn_or_schema.is_a?(String)
-          # New API: switch_schema('schema_name')
-          schema = conn_or_schema
-          conn = connection
-        else
-          # Old API: switch_schema(conn, 'schema_name')
-          conn = conn_or_schema
-        end
-
-        raise ArgumentError, "Schema name cannot be empty" if schema.nil? || schema.strip.empty?
+      # Switches the search_path to the specified schema
+      def switch_schema(schema_name)
+        raise ArgumentError, "Schema name cannot be empty" if schema_name.nil? || schema_name.strip.empty?
 
-        # Use simple quoting for PostgreSQL identifiers
-        quoted_schema = "\"#{schema.gsub('"', '""')}\""
+        conn = connection
+        quoted_schema = "\"#{schema_name.gsub('"', '""')}\""
         execute_sql(conn, "SET search_path TO #{quoted_schema};")
       end
 
-      # Reset to default schema - supports both APIs
-      def reset_schema(conn = nil)
-        conn ||= connection
+      # Reset to default schema
+      def reset_schema
+        conn = connection
         execute_sql(conn, "SET search_path TO public;")
       end
 
-      # Create a new schema - supports both APIs
-      def create_schema(conn_or_schema, schema_name = nil)
-        if conn_or_schema.is_a?(String)
-          # New API: create_schema('schema_name')
-          schema_name = conn_or_schema
-          conn = connection
-        else
-          # Old API: create_schema(conn, 'schema_name')
-          conn = conn_or_schema
-        end
-
+      # Create a new schema
+      def create_schema(schema_name)
         raise ArgumentError, "Schema name cannot be empty" if schema_name.nil? || schema_name.strip.empty?
 
+        conn = connection
         quoted_schema = "\"#{schema_name.gsub('"', '""')}\""
         execute_sql(conn, "CREATE SCHEMA IF NOT EXISTS #{quoted_schema};")
       end
 
-      # Drop a schema - supports both APIs
-      def drop_schema(conn_or_schema, schema_name_or_options = nil, cascade: true)
-        if conn_or_schema.is_a?(String)
-          # New API: drop_schema('schema_name', cascade: true)
-          schema_name = conn_or_schema
-          options = schema_name_or_options || {}
-          cascade = options.fetch(:cascade, cascade)
-          conn = connection
-        else
-          # Old API: drop_schema(conn, 'schema_name', cascade: true)
-          conn = conn_or_schema
-          schema_name = schema_name_or_options
-        end
-
+      # Drop a schema
+      def drop_schema(schema_name, cascade: true)
         raise ArgumentError, "Schema name cannot be empty" if schema_name.nil? || schema_name.strip.empty?
 
+        conn = connection
         cascade_option = cascade ? "CASCADE" : "RESTRICT"
         quoted_schema = "\"#{schema_name.gsub('"', '""')}\""
         execute_sql(conn, "DROP SCHEMA IF EXISTS #{quoted_schema} #{cascade_option};")
       end
 
-      # Check if schema exists - supports both APIs
-      def schema_exists?(conn_or_schema, schema_name = nil)
-        if conn_or_schema.is_a?(String)
-          # New API: schema_exists?('schema_name')
-          schema_name = conn_or_schema
-          conn = connection
-        else
-          # Old API: schema_exists?(conn, 'schema_name')
-          conn = conn_or_schema
-        end
-
+      # Check if schema exists
+      def schema_exists?(schema_name)
         return false if schema_name.nil? || schema_name.strip.empty?
 
+        conn = connection
         result = execute_sql(conn, <<~SQL)
           SELECT EXISTS(
             SELECT 1 FROM information_schema.schemata#{" "}
             WHERE schema_name = '#{schema_name}'
           ) AS schema_exists
         SQL
-        get_result_value(result, 0, 0) == "t"
+
+        value = get_result_value(result, 0, 0)
+        # Handle both boolean values and string representations
+        [true, "t", "true"].include?(value)
       end
 
-      # Get current schema - supports both APIs
-      def current_schema(conn = nil)
-        conn ||= connection
+      # Get current schema
+      def current_schema
+        conn = connection
         result = execute_sql(conn, "SELECT current_schema()")
         get_result_value(result, 0, 0)
       end
 
       private
 
-      # Execute SQL with Rails 8 compatibility
+      # Execute SQL - handles both Rails connections and raw PG connections
       def execute_sql(conn, sql)
         if conn.respond_to?(:execute)
-          # Rails connection - use execute
+          # Rails/ActiveRecord connection
           conn.execute(sql)
-        else
-          # Raw PG connection - use exec
+        elsif conn.respond_to?(:exec)
+          # Raw PG::Connection
           conn.exec(sql)
+        else
+          raise ArgumentError, "Connection must respond to either :execute or :exec"
         end
       end
 
-      # Get value from result with compatibility for different result types
+      # Get value from result - handles both Rails and PG results
       def get_result_value(result, row, col)
-        if result.respond_to?(:getvalue)
-          # PG::Result
+        if result.respond_to?(:rows)
+          # Rails ActiveRecord::Result
+          result.rows[row][col]
+        elsif result.respond_to?(:getvalue)
+          # Raw PG::Result
           result.getvalue(row, col)
+        elsif result.respond_to?(:[])
+          # Alternative PG::Result access
+          result[row][col]
         else
-          # ActiveRecord::Result
-          result.rows[row][col]
+          raise ArgumentError, "Result must respond to either :rows, :getvalue, or :[]"
         end
       end
     end

data/lib/pg_multitenant_schemas/tasks/advanced_tasks.rake

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Advanced tenant management tasks
+namespace :tenants do
+  desc "Run migrations for a specific tenant"
+  task :migrate_tenant, [:schema_name] => :environment do |_task, args|
+    require_relative "../tenant_task_helpers"
+    TenantTaskHelpers.migrate_specific_tenant(args[:schema_name])
+  end
+
+  desc "Setup new tenant with schema and migrations"
+  task :create, [:schema_name] => :environment do |_task, args|
+    require_relative "../tenant_task_helpers"
+    TenantTaskHelpers.create_tenant_with_schema(args[:schema_name])
+  end
+
+  desc "Setup schemas and run migrations for all existing tenants"
+  task setup: :environment do
+    PgMultitenantSchemas::Migrator.setup_all_tenants
+  end
+end

data/lib/pg_multitenant_schemas/tasks/basic_tasks.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Basic tenant management tasks
+namespace :tenants do
+  desc "List all tenant schemas"
+  task list: :environment do
+    require_relative "../tenant_task_helpers"
+    TenantTaskHelpers.list_tenant_schemas
+  end
+
+  desc "Show migration status for all tenants"
+  task status: :environment do
+    PgMultitenantSchemas::Migrator.migration_status
+  end
+
+  desc "Run migrations for all tenant schemas"
+  task migrate: :environment do
+    PgMultitenantSchemas::Migrator.migrate_all
+  end
+end

data/lib/pg_multitenant_schemas/tasks/pg_multitenant_schemas.rake

@@ -1,155 +1,65 @@
 # frozen_string_literal: true
 
-namespace :pg_multitenant_schemas do
-  desc "List all tenant schemas"
-  task :list_schemas => :environment do
-    puts "Available tenant schemas:"
-    
-    connection = ActiveRecord::Base.connection
-    schemas = connection.execute(
-      "SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast_temp_1', 'pg_temp_1', 'public') AND schema_name NOT LIKE 'pg_toast%'"
-    ).map { |row| row['schema_name'] }
-    
-    if schemas.any?
-      schemas.each { |schema| puts "  - #{schema}" }
-    else
-      puts "  No tenant schemas found"
-    end
-  end
+# Load individual task files
+Dir[File.join(File.dirname(__FILE__), "*.rake")].each { |file| load file unless file == __FILE__ }
 
-  desc "Create schema for a tenant"
-  task :create_schema, [:schema_name] => :environment do |task, args|
-    schema_name = args[:schema_name]
-    
-    if schema_name.blank?
-      puts "Usage: rails pg_multitenant_schemas:create_schema[schema_name]"
-      exit 1
-    end
-    
-    begin
-      connection = ActiveRecord::Base.connection
-      PgMultitenantSchemas::SchemaSwitcher.create_schema(connection, schema_name)
-      puts "Created schema: #{schema_name}"
-    rescue => e
-      puts "Error creating schema #{schema_name}: #{e.message}"
-      exit 1
-    end
-  end
+require_relative "../tenant_task_helpers"
 
-  desc "Drop schema for a tenant"
-  task :drop_schema, [:schema_name] => :environment do |task, args|
-    schema_name = args[:schema_name]
-    
-    if schema_name.blank?
-      puts "Usage: rails pg_multitenant_schemas:drop_schema[schema_name]"
-      exit 1
-    end
-    
-    if schema_name == 'public'
-      puts "Cannot drop public schema"
-      exit 1
-    end
-    
-    begin
-      connection = ActiveRecord::Base.connection
-      PgMultitenantSchemas::SchemaSwitcher.drop_schema(connection, schema_name)
-      puts "Dropped schema: #{schema_name}"
-    rescue => e
-      puts "Error dropping schema #{schema_name}: #{e.message}"
-      exit 1
-    end
+namespace :tenants do
+  desc "Create new tenant with attributes (JSON format)"
+  task :new, [:attributes] => :environment do |_task, args|
+    TenantTaskHelpers.create_tenant_with_attributes(args[:attributes])
   end
 
-  desc "Run migrations for all tenant schemas"
-  task :migrate_all => :environment do
-    puts "Running migrations for all tenant schemas..."
-    
-    connection = ActiveRecord::Base.connection
-    schemas = connection.execute(
-      "SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast_temp_1', 'pg_temp_1', 'public') AND schema_name NOT LIKE 'pg_toast%'"
-    ).map { |row| row['schema_name'] }
-    
-    original_schema = PgMultitenantSchemas.current_schema rescue 'public'
-    
-    schemas.each do |schema|
-      puts "Migrating schema: #{schema}"
-      begin
-        PgMultitenantSchemas.with_tenant(schema) do
-          # Rails 8 compatible migration execution
-          if Rails.version >= "8.0"
-            # Use Rails 8 migration API
-            ActiveRecord::Tasks::DatabaseTasks.migrate
-          else
-            # Fallback for older Rails versions
-            ActiveRecord::Migrator.migrate(Rails.application.paths["db/migrate"])
-          end
-        end
-        puts "  ✓ Completed migration for #{schema}"
-      rescue => e
-        puts "  ✗ Error migrating #{schema}: #{e.message}"
-      end
-    end
-    
-    # Restore original schema
-    PgMultitenantSchemas.current_schema = original_schema if defined?(PgMultitenantSchemas)
-    
-    puts "Completed migrations for #{schemas.count} schemas"
+  desc "Drop tenant schema (DANGEROUS)"
+  task :drop, [:schema_name] => :environment do |_task, args|
+    TenantTaskHelpers.drop_tenant_schema(args[:schema_name])
   end
 
-  desc "Setup multitenancy - create tenant schemas for existing tenants"
-  task :setup => :environment do
-    puts "Setting up multitenancy schemas..."
-    
-    if defined?(Tenant)
-      tenants = Tenant.all
-      
-      tenants.each do |tenant|
-        begin
-          puts "Creating schema for tenant: #{tenant.subdomain}"
-          PgMultitenantSchemas::SchemaSwitcher.create_schema(
-            ActiveRecord::Base.connection, 
-            tenant.subdomain
-          )
-          puts "  ✓ Schema created for #{tenant.subdomain}"
-        rescue => e
-          if e.message.include?("already exists")
-            puts "  - Schema #{tenant.subdomain} already exists"
-          else
-            puts "  ✗ Could not create schema for #{tenant.subdomain}: #{e.message}"
-          end
-        end
-      end
-      
-      puts "Setup completed for #{tenants.count} tenants"
-    else
-      puts "Tenant model not found. Make sure your Tenant model is defined."
-    end
+  desc "Rollback migrations for a tenant"
+  task :rollback, %i[schema_name steps] => :environment do |_task, args|
+    steps = (args[:steps] || 1).to_i
+    TenantTaskHelpers.rollback_tenant_migrations(args[:schema_name], steps)
   end
+end
+
+# Namespace aliases for convenience
+namespace :tenants do
+  namespace :db do
+    desc "Create tenant schema (alias for tenants:create)"
+    task :create, [:schema_name] => "tenants:create"
+
+    desc "Run tenant migrations (alias for tenants:migrate)"
+    task migrate: "tenants:migrate"
+
+    desc "Check tenant migration status (alias for tenants:status)"
+    task status: "tenants:status"
+
+    desc "Setup all tenants (alias for tenants:setup)"
+    task setup: "tenants:setup"
 
-  desc "Run migrations for a specific tenant schema"
-  task :migrate_tenant, [:schema_name] => :environment do |task, args|
-    schema_name = args[:schema_name]
-    
-    if schema_name.blank?
-      puts "Usage: rails pg_multitenant_schemas:migrate_tenant[schema_name]"
-      exit 1
-    end
-    
-    puts "Running migrations for tenant: #{schema_name}"
-    
-    begin
-      PgMultitenantSchemas.with_tenant(schema_name) do
-        # Rails 8 compatible migration execution
-        if Rails.version >= "8.0"
-          ActiveRecord::Tasks::DatabaseTasks.migrate
-        else
-          ActiveRecord::Migrator.migrate(Rails.application.paths["db/migrate"])
-        end
-      end
-      puts "✓ Completed migration for #{schema_name}"
-    rescue => e
-      puts "✗ Error migrating #{schema_name}: #{e.message}"
-      exit 1
-    end
+    desc "Rollback tenant migrations (alias for tenants:rollback)"
+    task :rollback, %i[schema_name steps] => "tenants:rollback"
   end
 end
+
+# Legacy namespace for backward compatibility
+namespace :pg_multitenant_schemas do
+  desc "DEPRECATED: Use 'tenants:list' instead"
+  task list_schemas: "tenants:list"
+
+  desc "DEPRECATED: Use 'tenants:migrate' instead"
+  task migrate_all: "tenants:migrate"
+
+  desc "DEPRECATED: Use 'tenants:setup' instead"
+  task setup: "tenants:setup"
+
+  desc "DEPRECATED: Use 'tenants:migrate_tenant[schema_name]' instead"
+  task :migrate_tenant, [:schema_name] => "tenants:migrate_tenant"
+
+  desc "DEPRECATED: Use 'tenants:create[schema_name]' instead"
+  task :create_schema, [:schema_name] => "tenants:create"
+
+  desc "DEPRECATED: Use 'tenants:drop[schema_name]' instead"
+  task :drop_schema, [:schema_name] => "tenants:drop"
+end

data/lib/pg_multitenant_schemas/tasks/tenant_tasks.rake

@@ -0,0 +1,65 @@
+# 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
+  desc "Create new tenant with attributes (JSON format)"
+  task :new, [:attributes] => :environment do |_task, args|
+    TenantTaskHelpers.create_tenant_with_attributes(args[:attributes])
+  end
+
+  desc "Drop tenant schema (DANGEROUS)"
+  task :drop, [:schema_name] => :environment do |_task, args|
+    TenantTaskHelpers.drop_tenant_schema(args[:schema_name])
+  end
+
+  desc "Rollback migrations for a tenant"
+  task :rollback, %i[schema_name steps] => :environment do |_task, args|
+    steps = (args[:steps] || 1).to_i
+    TenantTaskHelpers.rollback_tenant_migrations(args[:schema_name], steps)
+  end
+end
+
+# Namespace aliases for convenience
+namespace :tenants do
+  namespace :db do
+    desc "Create tenant schema (alias for tenants:create)"
+    task :create, [:schema_name] => "tenants:create"
+
+    desc "Run tenant migrations (alias for tenants:migrate)"
+    task migrate: "tenants:migrate"
+
+    desc "Check tenant migration status (alias for tenants:status)"
+    task status: "tenants:status"
+
+    desc "Setup all tenants (alias for tenants:setup)"
+    task setup: "tenants:setup"
+
+    desc "Rollback tenant migrations (alias for tenants:rollback)"
+    task :rollback, %i[schema_name steps] => "tenants:rollback"
+  end
+end
+
+# Legacy namespace for backward compatibility
+namespace :pg_multitenant_schemas do
+  desc "DEPRECATED: Use 'tenants:list' instead"
+  task list_schemas: "tenants:list"
+
+  desc "DEPRECATED: Use 'tenants:migrate' instead"
+  task migrate_all: "tenants:migrate"
+
+  desc "DEPRECATED: Use 'tenants:setup' instead"
+  task setup: "tenants:setup"
+
+  desc "DEPRECATED: Use 'tenants:migrate_tenant[schema_name]' instead"
+  task :migrate_tenant, [:schema_name] => "tenants:migrate_tenant"
+
+  desc "DEPRECATED: Use 'tenants:create[schema_name]' instead"
+  task :create_schema, [:schema_name] => "tenants:create"
+
+  desc "DEPRECATED: Use 'tenants:drop[schema_name]' instead"
+  task :drop_schema, [:schema_name] => "tenants:drop"
+end