ros-apartment 3.2.0 → 3.4.0

data/lib/apartment/tasks/task_helper.rb

@@ -1,54 +1,292 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/module/delegation'
+
 module Apartment
+  # Coordinates tenant operations for rake tasks with parallel execution support.
+  #
+  # ## Problem Context
+  #
+  # Multi-tenant applications with many schemas face slow migration times when
+  # running sequentially. A 100-tenant system with 2-second migrations takes
+  # 3+ minutes sequentially but ~20 seconds with 10 parallel workers.
+  #
+  # ## Why This Design
+  #
+  # Parallel database migrations introduce two categories of problems:
+  #
+  # 1. **Platform-specific fork safety**: macOS/Windows have issues with libpq
+  #    (PostgreSQL C library) after fork() due to GSS/Kerberos state corruption.
+  #    Linux handles fork() cleanly. We auto-detect and choose the safe strategy.
+  #
+  # 2. **PostgreSQL advisory lock deadlocks**: Rails uses advisory locks to
+  #    prevent concurrent migrations. When multiple processes/threads migrate
+  #    different schemas simultaneously, they deadlock competing for the same
+  #    lock. We disable advisory locks during parallel execution, which means
+  #    **you accept responsibility for ensuring your migrations are parallel-safe**.
+  #
+  # ## When to Use Parallel Migrations
+  #
+  # This is an advanced feature. Use it when:
+  # - You have many tenants and sequential migration time is problematic
+  # - Your migrations only modify tenant-specific schema objects
+  # - You've verified your migrations don't have cross-schema side effects
+  #
+  # Stick with sequential execution (the default) when:
+  # - Migrations create/modify extensions, types, or shared objects
+  # - Migrations have ordering dependencies across tenants
+  # - You're unsure whether parallel execution is safe for your use case
+  #
+  # ## Gotchas
+  #
+  # - The `parallel_migration_threads` count should be less than your connection
+  #   pool size to avoid connection exhaustion.
+  # - Empty/nil tenant names from `tenant_names` proc are filtered to prevent
+  #   PostgreSQL "zero-length delimited identifier" errors.
+  # - Process-based parallelism requires fresh connections in each fork;
+  #   thread-based parallelism shares the pool but needs explicit checkout.
+  #
+  # @see Apartment.parallel_migration_threads
+  # @see Apartment.parallel_strategy
+  # @see Apartment.manage_advisory_locks
   module TaskHelper
-    def self.each_tenant(&block)
-      Parallel.each(tenants_without_default, in_threads: Apartment.parallel_migration_threads) do |tenant|
-        Rails.application.executor.wrap do
-          block.call(tenant)
+    # Captures outcome per tenant for aggregated reporting. Allows migrations
+    # to continue for remaining tenants even when one fails.
+    Result = Struct.new(:tenant, :success, :error, keyword_init: true)
+
+    class << self
+      # Primary entry point for tenant iteration. Automatically selects
+      # sequential or parallel execution based on configuration.
+      #
+      # @yield [String] tenant name
+      # @return [Array<Result>] outcome for each tenant
+      def each_tenant(&)
+        return [] if tenants_without_default.empty?
+
+        if parallel_migration_threads.positive?
+          each_tenant_parallel(&)
+        else
+          each_tenant_sequential(&)
         end
       end
-    end
 
-    def self.tenants_without_default
-      tenants - [Apartment.default_tenant]
-    end
+      # Sequential execution: simpler, no connection management complexity.
+      # Used when parallel_migration_threads is 0 (the default).
+      def each_tenant_sequential
+        tenants_without_default.map do |tenant|
+          Rails.application.executor.wrap do
+            yield(tenant)
+          end
+          Result.new(tenant: tenant, success: true, error: nil)
+        rescue StandardError => e
+          Result.new(tenant: tenant, success: false, error: e.message)
+        end
+      end
 
-    def self.tenants
-      ENV['DB'] ? ENV['DB'].split(',').map(&:strip) : Apartment.tenant_names || []
-    end
+      # Parallel execution wrapper. Disables advisory locks for the duration,
+      # then delegates to platform-appropriate parallelism strategy.
+      def each_tenant_parallel(&)
+        with_advisory_locks_disabled do
+          case resolve_parallel_strategy
+          when :processes
+            each_tenant_in_processes(&)
+          else
+            each_tenant_in_threads(&)
+          end
+        end
+      end
 
-    def self.warn_if_tenants_empty
-      return unless tenants.empty? && ENV['IGNORE_EMPTY_TENANTS'] != 'true'
+      # Process-based parallelism via fork(). Faster on Linux due to
+      # copy-on-write memory and no GIL contention. Each forked process
+      # gets isolated memory, so we must clear inherited connections
+      # and establish fresh ones.
+      def each_tenant_in_processes
+        Parallel.map(tenants_without_default, in_processes: parallel_migration_threads) do |tenant|
+          # Forked processes inherit parent's connection handles but the
+          # underlying sockets are invalid. Must reconnect before any DB work.
+          ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+          reconnect_for_parallel_execution
 
-      puts <<-WARNING
-        [WARNING] - The list of tenants to migrate appears to be empty. This could mean a few things:
+          Rails.application.executor.wrap do
+            yield(tenant)
+          end
+          Result.new(tenant: tenant, success: true, error: nil)
+        rescue StandardError => e
+          Result.new(tenant: tenant, success: false, error: e.message)
+        ensure
+          ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+        end
+      end
 
-          1. You may not have created any, in which case you can ignore this message
-          2. You've run `apartment:migrate` directly without loading the Rails environment
-            * `apartment:migrate` is now deprecated. Tenants will automatically be migrated with `db:migrate`
+      # Thread-based parallelism. Safe on all platforms but subject to GIL
+      # for CPU-bound work (migrations are typically I/O-bound, so this is fine).
+      # Threads share the connection pool, so we reconfigure once before
+      # spawning and restore after completion.
+      def each_tenant_in_threads
+        original_config = ActiveRecord::Base.connection_db_config.configuration_hash
+        reconnect_for_parallel_execution
 
-        Note that your tenants currently haven't been migrated. You'll need to run `db:migrate` to rectify this.
-      WARNING
-    end
+        Parallel.map(tenants_without_default, in_threads: parallel_migration_threads) do |tenant|
+          # Explicit connection checkout prevents pool exhaustion when
+          # thread count exceeds pool size minus buffer.
+          ActiveRecord::Base.connection_pool.with_connection do
+            Rails.application.executor.wrap do
+              yield(tenant)
+            end
+          end
+          Result.new(tenant: tenant, success: true, error: nil)
+        rescue StandardError => e
+          Result.new(tenant: tenant, success: false, error: e.message)
+        end
+      ensure
+        ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+        ActiveRecord::Base.establish_connection(original_config) if original_config
+      end
 
-    def self.create_tenant(tenant_name)
-      puts("Creating #{tenant_name} tenant")
-      Apartment::Tenant.create(tenant_name)
-    rescue Apartment::TenantExists => e
-      puts "Tried to create already existing tenant: #{e}"
-    end
+      # Auto-detection logic for parallelism strategy. Only Linux gets
+      # process-based parallelism by default due to macOS libpq fork issues.
+      def resolve_parallel_strategy
+        strategy = Apartment.parallel_strategy
+
+        return :threads if strategy == :threads
+        return :processes if strategy == :processes
+
+        fork_safe_platform? ? :processes : :threads
+      end
+
+      # Platform detection. Conservative: only Linux is considered fork-safe.
+      # macOS has documented issues with libpq, GSS-API, and Kerberos after fork.
+      # See: https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNECT-GSSENCMODE
+      def fork_safe_platform?
+        RUBY_PLATFORM.include?('linux')
+      end
+
+      # Advisory lock management. Rails acquires pg_advisory_lock during migrations
+      # to prevent concurrent schema changes. With parallel tenant migrations,
+      # this causes deadlocks since all workers compete for the same lock.
+      #
+      # **Important**: Disabling advisory locks shifts responsibility to you.
+      # Your migrations must be safe to run concurrently across tenants. If your
+      # migrations modify shared resources, create extensions, or have other
+      # cross-schema side effects, parallel execution may cause failures.
+      # When in doubt, use sequential execution (parallel_migration_threads = 0).
+      #
+      # Uses ENV var because Rails checks it at connection establishment time,
+      # and we need it disabled before Parallel spawns workers.
+      def with_advisory_locks_disabled
+        return yield unless parallel_migration_threads.positive?
+        return yield unless Apartment.manage_advisory_locks
+
+        original_env_value = ENV.fetch('DISABLE_ADVISORY_LOCKS', nil)
+        begin
+          ENV['DISABLE_ADVISORY_LOCKS'] = 'true'
+          yield
+        ensure
+          if original_env_value.nil?
+            ENV.delete('DISABLE_ADVISORY_LOCKS')
+          else
+            ENV['DISABLE_ADVISORY_LOCKS'] = original_env_value
+          end
+        end
+      end
 
-    def self.migrate_tenant(tenant_name)
-      strategy = Apartment.db_migrate_tenant_missing_strategy
-      create_tenant(tenant_name) if strategy == :create_tenant
+      # Re-establishes database connection for parallel execution.
+      # When manage_advisory_locks is true, disables advisory locks in the
+      # connection config (belt-and-suspenders with the ENV var approach).
+      # When false, reconnects with existing config unchanged.
+      def reconnect_for_parallel_execution
+        current_config = ActiveRecord::Base.connection_db_config.configuration_hash
 
-      puts("Migrating #{tenant_name} tenant")
-      Apartment::Migrator.migrate tenant_name
-    rescue Apartment::TenantNotFound => e
-      raise e if strategy == :raise_exception
+        new_config = if Apartment.manage_advisory_locks
+                       current_config.merge(advisory_locks: false)
+                     else
+                       current_config
+                     end
 
-      puts e.message
+        ActiveRecord::Base.establish_connection(new_config)
+      end
+
+      # Delegate to Apartment.parallel_migration_threads
+      delegate :parallel_migration_threads, to: Apartment
+
+      # Get list of tenants excluding the default tenant
+      # Also filters out blank/empty tenant names to prevent errors
+      #
+      # @return [Array<String>] tenant names
+      def tenants_without_default
+        (tenants - [Apartment.default_tenant]).reject { |t| t.nil? || t.to_s.strip.empty? }
+      end
+
+      # Get list of all tenants to operate on
+      # Supports DB env var for targeting specific tenants
+      # Filters out blank tenant names for safety
+      #
+      # @return [Array<String>] tenant names
+      def tenants
+        result = ENV['DB'] ? ENV['DB'].split(',').map(&:strip) : Apartment.tenant_names || []
+        result.reject { |t| t.nil? || t.to_s.strip.empty? }
+      end
+
+      # Display warning if tenant list is empty
+      def warn_if_tenants_empty
+        return unless tenants.empty? && ENV['IGNORE_EMPTY_TENANTS'] != 'true'
+
+        puts <<~WARNING
+          [WARNING] - The list of tenants to migrate appears to be empty. This could mean a few things:
+
+            1. You may not have created any, in which case you can ignore this message
+            2. You've run `apartment:migrate` directly without loading the Rails environment
+              * `apartment:migrate` is now deprecated. Tenants will automatically be migrated with `db:migrate`
+
+          Note that your tenants currently haven't been migrated. You'll need to run `db:migrate` to rectify this.
+        WARNING
+      end
+
+      # Display summary of operation results
+      #
+      # @param operation [String] name of the operation (e.g., "Migration", "Rollback")
+      # @param results [Array<Result>] results from each_tenant
+      def display_summary(operation, results)
+        return if results.empty?
+
+        succeeded = results.count(&:success)
+        failed = results.reject(&:success)
+
+        puts "\n=== #{operation} Summary ==="
+        puts "Succeeded: #{succeeded}/#{results.size} tenants"
+
+        return if failed.empty?
+
+        puts "Failed: #{failed.size} tenants"
+        failed.each do |result|
+          puts "  - #{result.tenant}: #{result.error}"
+        end
+      end
+
+      # Create a tenant with logging
+      #
+      # @param tenant_name [String] name of tenant to create
+      def create_tenant(tenant_name)
+        puts("Creating #{tenant_name} tenant")
+        Apartment::Tenant.create(tenant_name)
+      rescue Apartment::TenantExists => e
+        puts "Tried to create already existing tenant: #{e}"
+      end
+
+      # Migrate a single tenant with error handling based on strategy
+      #
+      # @param tenant_name [String] name of tenant to migrate
+      def migrate_tenant(tenant_name)
+        strategy = Apartment.db_migrate_tenant_missing_strategy
+        create_tenant(tenant_name) if strategy == :create_tenant
+
+        puts("Migrating #{tenant_name} tenant")
+        Apartment::Migrator.migrate(tenant_name)
+      rescue Apartment::TenantNotFound => e
+        raise(e) if strategy == :raise_exception
+
+        puts e.message
+      end
     end
   end
 end

data/lib/apartment/tenant.rb

@@ -32,13 +32,13 @@ module Apartment
         end
 
         begin
-          require "apartment/adapters/#{adapter_method}"
+          require("apartment/adapters/#{adapter_method}")
         rescue LoadError
-          raise "The adapter `#{adapter_method}` is not yet supported"
+          raise("The adapter `#{adapter_method}` is not yet supported")
         end
 
         unless respond_to?(adapter_method)
-          raise AdapterNotFound, "database configuration specifies nonexistent #{config[:adapter]} adapter"
+          raise(AdapterNotFound, "database configuration specifies nonexistent #{config[:adapter]} adapter")
         end
 
         send(adapter_method, config)

data/lib/apartment/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Apartment
-  VERSION = '3.2.0'
+  VERSION = '3.4.0'
 end

data/lib/apartment.rb

@@ -28,7 +28,8 @@ module Apartment
     WRITER_METHODS = %i[tenant_names database_schema_file excluded_models
                         persistent_schemas connection_class
                         db_migrate_tenants db_migrate_tenant_missing_strategy seed_data_file
-                        parallel_migration_threads pg_excluded_names].freeze
+                        parallel_migration_threads pg_excluded_names
+                        parallel_strategy manage_advisory_locks].freeze
 
     attr_accessor(*ACCESSOR_METHODS)
     attr_writer(*WRITER_METHODS)
@@ -41,7 +42,7 @@ module Apartment
 
     # configure apartment with available options
     def configure
-      yield self if block_given?
+      yield(self) if block_given?
     end
 
     def tenant_names
@@ -57,7 +58,7 @@ module Apartment
     end
 
     def db_config_for(tenant)
-      (tenants_with_config[tenant] || connection_config)
+      tenants_with_config[tenant] || connection_config
     end
 
     # Whether or not db:migrate should also migrate tenants
@@ -68,9 +69,10 @@ module Apartment
       @db_migrate_tenants = true
     end
 
-    # How to handle tenant missing on db:migrate
-    # defaults to :rescue_exception
-    # available options: rescue_exception, raise_exception, create_tenant
+    # How to handle missing tenants during db:migrate
+    # :rescue_exception (default) - Log error, continue with other tenants
+    # :raise_exception - Stop migration immediately
+    # :create_tenant - Automatically create missing tenant and migrate
     def db_migrate_tenant_missing_strategy
       valid = %i[rescue_exception raise_exception create_tenant]
       value = @db_migrate_tenant_missing_strategy || :rescue_exception
@@ -80,7 +82,7 @@ module Apartment
       key_name  = 'config.db_migrate_tenant_missing_strategy'
       opt_names = valid.join(', ')
 
-      raise ApartmentError, "Option #{value} not valid for `#{key_name}`. Use one of #{opt_names}"
+      raise(ApartmentError, "Option #{value} not valid for `#{key_name}`. Use one of #{opt_names}")
     end
 
     # Default to empty array
@@ -92,6 +94,24 @@ module Apartment
       @parallel_migration_threads || 0
     end
 
+    # Parallelism strategy for migrations
+    # :auto (default) - Detect platform: processes on Linux, threads on macOS/Windows
+    # :threads - Always use threads (safer, works everywhere)
+    # :processes - Always use processes (faster on Linux, may crash on macOS/Windows)
+    def parallel_strategy
+      @parallel_strategy || :auto
+    end
+
+    # Whether to manage PostgreSQL advisory locks during parallel migrations
+    # When true and parallel_migration_threads > 0, advisory locks are disabled
+    # during migration to prevent deadlocks, then restored afterward.
+    # Default: true
+    def manage_advisory_locks
+      return @manage_advisory_locks if defined?(@manage_advisory_locks)
+
+      @manage_advisory_locks = true
+    end
+
     def persistent_schemas
       @persistent_schemas || []
     end
@@ -126,14 +146,19 @@ module Apartment
     def extract_tenant_config
       return {} unless @tenant_names
 
+      # Execute callable (proc/lambda) to get dynamic tenant list from database
       values = @tenant_names.respond_to?(:call) ? @tenant_names.call : @tenant_names
-      unless values.is_a? Hash
-        values = values.each_with_object({}) do |tenant, hash|
-          hash[tenant] = connection_config
+
+      # Normalize arrays to hash format (tenant_name => connection_config)
+      unless values.is_a?(Hash)
+        values = values.index_with do |_tenant|
+          connection_config
         end
       end
       values.with_indifferent_access
     rescue ActiveRecord::StatementInvalid
+      # Database query failed (table doesn't exist yet, connection issue)
+      # Return empty hash to allow app to boot without tenants
       {}
     end
   end

data/lib/generators/apartment/install/install_generator.rb

@@ -5,7 +5,7 @@ module Apartment
     source_root File.expand_path('templates', __dir__)
 
     def copy_files
-      template 'apartment.rb', File.join('config', 'initializers', 'apartment.rb')
+      template('apartment.rb', File.join('config', 'initializers', 'apartment.rb'))
     end
   end
 end

data/lib/generators/apartment/install/templates/apartment.rb

@@ -50,7 +50,7 @@ Apartment.configure do |config|
   #   end
   # end
   #
-  config.tenant_names = -> { ToDo_Tenant_Or_User_Model.pluck :database }
+  config.tenant_names = -> { ToDo_Tenant_Or_User_Model.pluck(:database) }
 
   # PostgreSQL:
   #   Specifies whether to use PostgreSQL schemas or create a new database per Tenant.
@@ -111,6 +111,6 @@ end
 # }
 
 # Rails.application.config.middleware.use Apartment::Elevators::Domain
-Rails.application.config.middleware.use Apartment::Elevators::Subdomain
+Rails.application.config.middleware.use(Apartment::Elevators::Subdomain)
 # Rails.application.config.middleware.use Apartment::Elevators::FirstSubdomain
 # Rails.application.config.middleware.use Apartment::Elevators::Host

data/lib/tasks/apartment.rake

@@ -2,11 +2,12 @@
 
 require 'apartment/migrator'
 require 'apartment/tasks/task_helper'
+require 'apartment/tasks/schema_dumper'
 require 'parallel'
 
-apartment_namespace = namespace :apartment do
-  desc 'Create all tenants'
-  task :create do
+apartment_namespace = namespace(:apartment) do
+  desc('Create all tenants')
+  task(create: :environment) do
     Apartment::TaskHelper.warn_if_tenants_empty
 
     Apartment::TaskHelper.tenants.each do |tenant|
@@ -14,8 +15,8 @@ apartment_namespace = namespace :apartment do
     end
   end
 
-  desc 'Drop all tenants'
-  task :drop do
+  desc('Drop all tenants')
+  task(drop: :environment) do
     Apartment::TaskHelper.tenants.each do |tenant|
       puts("Dropping #{tenant} tenant")
       Apartment::Tenant.drop(tenant)
@@ -24,16 +25,29 @@ apartment_namespace = namespace :apartment do
     end
   end
 
-  desc 'Migrate all tenants'
-  task :migrate do
+  desc('Migrate all tenants')
+  task(migrate: :environment) do
     Apartment::TaskHelper.warn_if_tenants_empty
-    Apartment::TaskHelper.each_tenant do |tenant|
+
+    results = Apartment::TaskHelper.each_tenant do |tenant|
       Apartment::TaskHelper.migrate_tenant(tenant)
     end
+
+    Apartment::TaskHelper.display_summary('Migration', results)
+
+    # Dump schema after successful migrations
+    if results.all?(&:success)
+      Apartment::Tasks::SchemaDumper.dump_if_enabled
+    else
+      puts '[Apartment] Skipping schema dump due to migration failures'
+    end
+
+    # Exit with non-zero status if any tenant failed
+    exit(1) if results.any? { |r| !r.success }
   end
 
-  desc 'Seed all tenants'
-  task :seed do
+  desc('Seed all tenants')
+  task(seed: :environment) do
     Apartment::TaskHelper.warn_if_tenants_empty
 
     Apartment::TaskHelper.each_tenant do |tenant|
@@ -47,54 +61,67 @@ apartment_namespace = namespace :apartment do
     end
   end
 
-  desc 'Rolls the migration back to the previous version (specify steps w/ STEP=n) across all tenants.'
-  task :rollback do
+  desc('Rolls the migration back to the previous version (specify steps w/ STEP=n) across all tenants.')
+  task(rollback: :environment) do
     Apartment::TaskHelper.warn_if_tenants_empty
 
-    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    step = ENV.fetch('STEP', '1').to_i
 
-    Apartment::TaskHelper.each_tenant do |tenant|
+    results = Apartment::TaskHelper.each_tenant do |tenant|
       puts("Rolling back #{tenant} tenant")
-      Apartment::Migrator.rollback tenant, step
-    rescue Apartment::TenantNotFound => e
-      puts e.message
+      Apartment::Migrator.rollback(tenant, step)
+    end
+
+    Apartment::TaskHelper.display_summary('Rollback', results)
+
+    # Dump schema after successful rollback
+    if results.all?(&:success)
+      Apartment::Tasks::SchemaDumper.dump_if_enabled
+    else
+      puts '[Apartment] Skipping schema dump due to rollback failures'
     end
+
+    exit(1) if results.any? { |r| !r.success }
   end
 
-  namespace :migrate do
-    desc 'Runs the "up" for a given migration VERSION across all tenants.'
-    task :up do
+  namespace(:migrate) do
+    desc('Runs the "up" for a given migration VERSION across all tenants.')
+    task(up: :environment) do
       Apartment::TaskHelper.warn_if_tenants_empty
 
-      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
+      version = ENV.fetch('VERSION', nil)&.to_i
+      raise('VERSION is required') unless version
 
-      Apartment::TaskHelper.each_tenant do |tenant|
+      results = Apartment::TaskHelper.each_tenant do |tenant|
         puts("Migrating #{tenant} tenant up")
-        Apartment::Migrator.run :up, tenant, version
-      rescue Apartment::TenantNotFound => e
-        puts e.message
+        Apartment::Migrator.run(:up, tenant, version)
       end
+
+      Apartment::TaskHelper.display_summary('Migrate Up', results)
+      Apartment::Tasks::SchemaDumper.dump_if_enabled if results.all?(&:success)
+      exit(1) if results.any? { |r| !r.success }
     end
 
-    desc 'Runs the "down" for a given migration VERSION across all tenants.'
-    task :down do
+    desc('Runs the "down" for a given migration VERSION across all tenants.')
+    task(down: :environment) do
       Apartment::TaskHelper.warn_if_tenants_empty
 
-      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
+      version = ENV.fetch('VERSION', nil)&.to_i
+      raise('VERSION is required') unless version
 
-      Apartment::TaskHelper.each_tenant do |tenant|
+      results = Apartment::TaskHelper.each_tenant do |tenant|
         puts("Migrating #{tenant} tenant down")
-        Apartment::Migrator.run :down, tenant, version
-      rescue Apartment::TenantNotFound => e
-        puts e.message
+        Apartment::Migrator.run(:down, tenant, version)
       end
+
+      Apartment::TaskHelper.display_summary('Migrate Down', results)
+      Apartment::Tasks::SchemaDumper.dump_if_enabled if results.all?(&:success)
+      exit(1) if results.any? { |r| !r.success }
     end
 
-    desc 'Rolls back the tenant one migration and re migrate up (options: STEP=x, VERSION=x).'
-    task :redo do
-      if ENV['VERSION']
+    desc('Rolls back the tenant one migration and re migrate up (options: STEP=x, VERSION=x).')
+    task(:redo) do
+      if ENV.fetch('VERSION', nil)
         apartment_namespace['migrate:down'].invoke
         apartment_namespace['migrate:up'].invoke
       else

data/ros-apartment.gemspec

@@ -32,9 +32,9 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 3.1'
 
-  s.add_dependency('activerecord', '>= 6.1.0', '< 8.1')
-  s.add_dependency('activesupport', '>= 6.1.0', '< 8.1')
+  s.add_dependency('activerecord', '>= 7.0.0', '< 8.2')
+  s.add_dependency('activesupport', '>= 7.0.0', '< 8.2')
   s.add_dependency('parallel', '< 2.0')
-  s.add_dependency('public_suffix', '>= 2.0.5', '<= 6.0.1')
+  s.add_dependency('public_suffix', '>= 2.0.5', '< 7')
   s.add_dependency('rack', '>= 1.3.6', '< 4.0')
 end