pg_multitenant_schemas 0.2.2 → 0.3.6

data/docs/testing_rails_tasks.md

@@ -0,0 +1,128 @@
+# 🧪 Testing Rails Tasks in PG Multitenant Schemas
+
+## 🚨 Important: Testing Context
+
+The `rails tenants:list` command only works **within a Rails application** that includes this gem, not in the gem directory itself.
+
+## 🔧 Fixed Issues
+
+✅ **Removed circular dependency** in rake task loading
+✅ **Eliminated duplicate task files** (`pg_multitenant_schemas.rake` was identical to `tenant_tasks.rake`)
+✅ **Updated railtie** to load all task files properly
+✅ **Added missing `list_schemas` method** to `SchemaSwitcher` class
+✅ **Fixed Rails 8 migration_context compatibility** - Updated migration handling for Rails 8
+
+## 🚀 How to Test the Rails Tasks
+
+### **Option 1: Create a Test Rails App**
+
+```bash
+# Create a new Rails app for testing
+rails new test_multitenancy --database=postgresql
+cd test_multitenancy
+
+# Add the gem to Gemfile
+echo 'gem "pg_multitenant_schemas", path: "/Users/rubenpaz/personal/pg_multitenant_schemas"' >> Gemfile
+
+# Install the gem
+bundle install
+
+# Now you can test the tasks
+rails tenants:list
+rails tenants:status
+rails tenants:migrate
+```
+
+### **Option 2: Use an Existing Rails App**
+
+```bash
+# Navigate to your existing Rails app
+cd /Users/rubenpaz/personal/lbyte-security  # or wherever your Rails app is
+
+# Add gem to Gemfile if not already added
+# gem "pg_multitenant_schemas", path: "/Users/rubenpaz/personal/pg_multitenant_schemas"
+
+# Install and test
+bundle install
+rails tenants:list
+```
+
+### **Option 3: Test in the Example Directory**
+
+```bash
+# If there's a Rails example in the gem
+cd /Users/rubenpaz/personal/pg_multitenant_schemas/examples
+# Follow instructions in that directory
+```
+
+## 📋 Available Tasks
+
+After including the gem in a Rails app, you'll have these tasks:
+
+### **Basic Tasks**
+- `rails tenants:list` - List all tenant schemas
+- `rails tenants:status` - Show migration status for all tenants  
+- `rails tenants:migrate` - Run migrations for all tenant schemas
+
+### **Advanced Tasks**  
+- `rails tenants:migrate_tenant[schema_name]` - Run migrations for specific tenant
+- `rails tenants:create[schema_name]` - Setup new tenant with schema and migrations
+- `rails tenants:setup` - Setup schemas and run migrations for all existing tenants
+
+### **Management Tasks**
+- `rails tenants:new[attributes]` - Create new tenant with attributes (JSON format)
+- `rails tenants:drop[schema_name]` - Drop tenant schema (DANGEROUS)
+- `rails tenants:rollback[schema_name,steps]` - Rollback migrations for a tenant
+
+### **Convenience Aliases**
+- `rails tenants:db:create[schema_name]` - Alias for `tenants:create`
+- `rails tenants:db:migrate` - Alias for `tenants:migrate`
+- `rails tenants:db:status` - Alias for `tenants:status`
+
+### **Legacy Tasks (Deprecated)**
+- `rails pg_multitenant_schemas:list_schemas` - Use `tenants:list` instead
+- `rails pg_multitenant_schemas:migrate_all` - Use `tenants:migrate` instead
+
+## 🛠️ Troubleshooting
+
+### "Command not found" or "stack level too deep"
+- ✅ **Fixed**: Circular dependency in task loading removed
+- Make sure you're in a Rails application directory
+- Run `bundle install` after adding the gem
+
+### "NoMethodError: undefined method 'list_schemas'"  
+- ✅ **Fixed**: Added missing `list_schemas` method to `SchemaSwitcher`
+- Update to the latest version of the gem
+
+### "NoMethodError: undefined method 'migration_context'"
+- ✅ **Fixed**: Updated migration handling for Rails 8 compatibility
+- The gem now properly handles migration context access across Rails versions
+- Update to the latest version of the gem
+
+### "No such task"
+- Ensure the gem is properly added to your Rails app's Gemfile
+- Run `bundle install`
+- Check that the gem is loading: `rails runner "puts PgMultitenantSchemas::VERSION"`
+
+### "Environment not loaded"
+- The tasks require `:environment`, so they need a proper Rails environment
+- Make sure your Rails app's database is configured and accessible
+
+## 🧪 Quick Test
+
+To verify everything works, create a minimal test:
+
+```bash
+# In your Rails app directory
+rails runner "puts 'Gem loaded: ' + PgMultitenantSchemas::VERSION"
+rails tenants:list
+```
+
+## 📁 Task File Structure
+
+The gem now has a clean task structure:
+- `basic_tasks.rake` - List, status, migrate tasks
+- `advanced_tasks.rake` - Advanced tenant management  
+- `tenant_tasks.rake` - Management tasks + aliases + legacy compatibility
+
+All are loaded automatically via the Rails railtie when you include the gem in your Rails application.

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/migration_schema_operations.rb

@@ -34,21 +34,115 @@ module PgMultitenantSchemas
     end
 
     def run_migrations
-      ActiveRecord::Base.connection.migrate
+      # Use the migration context to run migrations
+      migration_context_obj = migration_context
+      return unless migration_context_obj
+
+      migration_context_obj.migrate
     end
 
     def pending_migrations
-      ActiveRecord::Base.connection.migration_context.migrations.reject do |migration|
-        ActiveRecord::Base.connection.migration_context.get_all_versions.include?(migration.version)
+      migration_context_obj = migration_context
+      return [] unless migration_context_obj
+
+      all_migrations = migration_context_obj.migrations
+      applied_version_list = applied_versions
+
+      all_migrations.reject do |migration|
+        applied_version_list.include?(migration.version)
       end
     end
 
     def applied_migrations
-      ActiveRecord::Base.connection.migration_context.get_all_versions
+      applied_versions
     end
 
     def migration_paths
-      ActiveRecord::Base.connection.migration_context.migrations_paths
+      migration_context_obj = migration_context
+      if migration_context_obj.respond_to?(:migrations_paths)
+        migration_context_obj.migrations_paths
+      elsif defined?(::Rails) && ::Rails.application
+        # Fallback to default Rails migration paths
+        ::Rails.application.paths["db/migrate"].expanded
+      else
+        ["db/migrate"]
+      end
+    end
+
+    def migration_context
+      # Return nil if ActiveRecord is not available (for tests)
+      return nil unless defined?(ActiveRecord::Base)
+
+      # Rails 8 compatibility: Try multiple approaches
+      find_migration_context
+    rescue StandardError => e
+      # Use explicit Rails logger to avoid namespace conflicts
+      ::Rails.logger&.warn("Failed to get migration context: #{e.message}") if defined?(::Rails)
+      nil
+    end
+
+    def find_migration_context
+      if ActiveRecord::Base.respond_to?(:migration_context)
+        # Rails 8+: Try base migration context first
+        ActiveRecord::Base.migration_context
+      elsif ActiveRecord::Base.connection.respond_to?(:migration_context)
+        # Rails 7: Use connection migration context
+        ActiveRecord::Base.connection.migration_context
+      elsif defined?(ActiveRecord::MigrationContext)
+        # Fallback: Create a new migration context with default paths
+        create_fallback_migration_context
+      end
+    end
+
+    def create_fallback_migration_context
+      paths = if defined?(::Rails) && ::Rails.application
+                ::Rails.application.paths["db/migrate"].expanded
+              else
+                ["db/migrate"]
+              end
+      ActiveRecord::MigrationContext.new(paths)
+    end
+
+    # Get applied migration versions with Rails 8 compatibility
+    def applied_versions
+      # Return empty array if ActiveRecord is not available (for tests)
+      return [] unless defined?(ActiveRecord::Base)
+
+      applied_versions_from_context || applied_versions_from_database
+    rescue StandardError => e
+      # If anything fails, return empty array
+      ::Rails.logger&.warn("Failed to get applied versions: #{e.message}") if defined?(::Rails)
+      []
+    end
+
+    def applied_versions_from_context
+      # Try using migration context first (for tests and Rails 7)
+      migration_context_obj = migration_context
+      return migration_context_obj.get_all_versions if migration_context_obj.respond_to?(:get_all_versions)
+
+      nil
+    end
+
+    def applied_versions_from_database
+      # Fallback to direct database query (Rails 8)
+      connection = ActiveRecord::Base.connection
+      table_name = "schema_migrations"
+
+      ensure_schema_migrations_table_exists(connection, table_name)
+
+      # Query the table directly for maximum compatibility
+      connection.select_values("SELECT version FROM #{table_name} ORDER BY version")
+    end
+
+    def ensure_schema_migrations_table_exists(connection, table_name)
+      # Ensure the schema_migrations table exists
+      return if connection.table_exists?(table_name)
+
+      # Create the table if it doesn't exist
+      connection.create_table(table_name, id: false) do |t|
+        t.string :version, null: false
+      end
+      connection.add_index(table_name, :version, unique: true, name: "unique_schema_migrations")
     end
   end
 end

data/lib/pg_multitenant_schemas/migrator.rb

@@ -73,15 +73,72 @@ module PgMultitenantSchemas
         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
+        perform_rollback(schema_name, steps, verbose)
+      ensure
+        switch_to_schema(original_schema) if original_schema
+      end
+
+      private
+
+      def perform_rollback(schema_name, steps, verbose)
+        switch_to_schema(schema_name)
+        migration_context_obj = migration_context
+
+        unless migration_context_obj
+          puts "  ❌ Cannot rollback: migration context not available" if verbose
+          return
+        end
+
+        migration_context_obj.rollback(migration_paths, steps)
+        puts "  ✅ Rollback completed" if verbose
+      rescue StandardError => e
+        puts "  ❌ Rollback failed: #{e.message}" if verbose
+        raise
+      end
+
+      def migration_context
+        # Return nil if ActiveRecord is not available (for tests)
+        return nil unless defined?(ActiveRecord::Base)
+
+        # Rails 8 compatibility: Try multiple approaches
+        find_migration_context
+      rescue StandardError => e
+        # Use explicit Rails logger to avoid namespace conflicts
+        ::Rails.logger&.warn("Failed to get migration context: #{e.message}") if defined?(::Rails)
+        nil
+      end
+
+      def find_migration_context
+        if ActiveRecord::Base.respond_to?(:migration_context)
+          # Rails 8+: Try base migration context first
+          ActiveRecord::Base.migration_context
+        elsif ActiveRecord::Base.connection.respond_to?(:migration_context)
+          # Rails 7: Use connection migration context
+          ActiveRecord::Base.connection.migration_context
+        elsif defined?(ActiveRecord::MigrationContext)
+          # Fallback: Create a new migration context with default paths
+          create_fallback_migration_context
+        end
+      end
+
+      def create_fallback_migration_context
+        paths = if defined?(::Rails) && ::Rails.application
+                  ::Rails.application.paths["db/migrate"].expanded
+                else
+                  ["db/migrate"]
+                end
+        ActiveRecord::MigrationContext.new(paths)
+      end
+
+      def migration_paths
+        migration_context_obj = migration_context
+        if migration_context_obj.respond_to?(:migrations_paths)
+          migration_context_obj.migrations_paths
+        elsif defined?(::Rails) && ::Rails.application
+          # Fallback to default Rails migration paths
+          ::Rails.application.paths["db/migrate"].expanded
+        else
+          ["db/migrate"]
         end
       end
     end

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