activerecord-tenanted 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dbae49297c735850801a4994217ba8ce3ff794345159748c881c6e5e33a6b86
-  data.tar.gz: 42e0b45e14927d7c403db84baf20499c9297572993d30526522e0ecb810ad87f
+  metadata.gz: 62c3b9d7f37db44de60c7559e4b10e1407171ab29aa874e2687853e8acc38bb1
+  data.tar.gz: 27b2ee871ff4ce67b60480e83694cf6a2aeac504b3ab39f96ea0eb243b5f3a47
 SHA512:
-  metadata.gz: d897569771373793bb56468562b9070d523d1cebe1a2fa1acd7da8e7db40d92f59c8e51439161f33d5c9e3456c9d5797499b2596fc5dcc515b5a4b93959f8122
-  data.tar.gz: f4edce93a3be90e901251be1b00f788753056c94d4fe0c1df71fcccd0b28aba52f9116c2f144ac94a1b72acb194d44a1e7736df0d971c520088c4a2fd5cddb85
+  metadata.gz: 7eff54730cbc865dd8ecb1169e146194b0edceaed0527059ed110537aedd57901a5a5af5b85c522bfebcf50714c468984f91ac4f5c8e40077b2e737497eac550
+  data.tar.gz: fafa6f206173a7057e090407f5cf6698bd7f1d34885509793568f1e76baedbe61b7eeea980493b5af0df30c3f5bd20400c799eebecf62785f458e925afbee57f

data/lib/active_record/tenanted/connection_adapter.rb

@@ -2,18 +2,27 @@
 
 module ActiveRecord
   module Tenanted
-    module ConnectionAdapter # :nodoc:
+    #
+    #  Extends ActiveRecord::ConnectionAdapters::AbstractAdapter with a `tenant` attribute.
+    #
+    #  This is useful in conjunction with the `:tenant` query log tag, which configures logging of
+    #  the tenant in SQL query logs (when `config.active_record.query_log_tags_enabled` is set to
+    #  `true`). For example:
+    #
+    #      Rails.application.config.active_record.query_log_tags_enabled = true
+    #      Rails.application.config.active_record.query_log_tags = [ :tenant ]
+    #
+    #  will cause the application to emit logs like:
+    #
+    #      User Load (0.2ms)  SELECT "users".* FROM "users" ORDER BY "users"."id" ASC LIMIT 1 /*tenant='foo'*/
+    #
+    module ConnectionAdapter
       extend ActiveSupport::Concern
 
       prepended do
         attr_accessor :tenant
       end
 
-      def log(sql, name = "SQL", binds = [], type_casted_binds = [], async: false, allow_retry: false, &block)
-        name = [ name, "[tenant=#{tenant}]" ].compact.join(" ") if tenanted?
-        super
-      end
-
       def tenanted?
         tenant.present?
       end

data/lib/active_record/tenanted/console.rb

@@ -5,7 +5,11 @@ module ActiveRecord
     module Console # :nodoc:
       module IRBConsole
         def start
-          ActiveRecord::Tenanted::DatabaseTasks.set_current_tenant if Rails.env.local?
+          # TODO: we could be setting the current tenant for all tenanted configs.
+          if Rails.env.local? && ActiveRecord::Tenanted.connection_class
+            config = ActiveRecord::Tenanted.connection_class.connection_pool.db_config
+            ActiveRecord::Tenanted::DatabaseTasks.new(config).set_current_tenant
+          end
           super
         end
       end

data/lib/active_record/tenanted/database_adapter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module DatabaseAdapter # :nodoc:
+      # Hash of registered database configuration adapters
+      @adapters = {}
+
+      class << self
+        def register(name, class_name)
+          @adapters[name.to_s] = class_name
+        end
+
+        def new(db_config)
+          adapter_class_name = @adapters[db_config.adapter]
+
+          if adapter_class_name.nil?
+            raise ActiveRecord::Tenanted::UnsupportedDatabaseError,
+                  "Unsupported database adapter for tenanting: #{db_config.adapter}. " \
+                  "Supported adapters: #{@adapters.keys.join(', ')}"
+          end
+
+          adapter_class_name.constantize.new(db_config)
+        end
+      end
+
+      register "sqlite3", "ActiveRecord::Tenanted::DatabaseAdapters::SQLite"
+    end
+  end
+end

data/lib/active_record/tenanted/database_adapters/sqlite.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module DatabaseAdapters # :nodoc:
+      #
+      #  TODO: This still feels to me like it's not _quite_ right. I think we could further refactor this by:
+      #
+      #  1. Moving tenant_databases and validate_tenant_name to BaseConfig, and subclassing it for
+      #     each database
+      #  2. Moving create_database, drop_database, database_exist?, database_ready?,
+      #     acquire_ready_lock, ensure_database_directory_exists, and database_path to the SQLite
+      #     connection adapter, possibly into Rails
+      #  3. Moving test_workerize and path_for to be SQLite connection adapter class methods,
+      #     possibly into Rails
+      #
+      class SQLite
+        attr_reader :db_config
+
+        def initialize(db_config)
+          @db_config = db_config
+        end
+
+        def tenant_databases
+          glob = path_for(db_config.database_for("*"))
+          scanner = Regexp.new(path_for(db_config.database_for("(.+)")))
+
+          Dir.glob(glob).filter_map do |path|
+            result = path.scan(scanner).flatten.first
+            if result.nil?
+              Rails.logger.warn "ActiveRecord::Tenanted: Cannot parse tenant name from filename #{path.inspect}"
+            end
+            result
+          end
+        end
+
+        def validate_tenant_name(tenant_name)
+          if tenant_name.match?(%r{[/'"`]})
+            raise BadTenantNameError, "Tenant name contains an invalid character: #{tenant_name.inspect}"
+          end
+        end
+
+        def create_database
+          ensure_database_directory_exists
+          FileUtils.touch(database_path)
+        end
+
+        def drop_database
+          # Remove the SQLite database file and associated files
+          FileUtils.rm_f(database_path)
+          FileUtils.rm_f("#{database_path}-wal")  # Write-Ahead Logging file
+          FileUtils.rm_f("#{database_path}-shm")  # Shared Memory file
+        end
+
+        def database_exist?
+          File.exist?(database_path)
+        end
+
+        def database_ready?
+          File.exist?(database_path) && !ActiveRecord::Tenanted::Mutex::Ready.locked?(database_path)
+        end
+
+        def acquire_ready_lock(&block)
+          ActiveRecord::Tenanted::Mutex::Ready.lock(database_path, &block)
+        end
+
+        def ensure_database_directory_exists
+          return unless database_path
+
+          database_dir = File.dirname(database_path)
+          unless File.directory?(database_dir)
+            FileUtils.mkdir_p(database_dir)
+          end
+        end
+
+        def database_path
+          path_for(db_config.database)
+        end
+
+        def test_workerize(db, test_worker_id)
+          test_worker_suffix = "_#{test_worker_id}"
+
+          if db.start_with?("file:") && db.include?("?")
+            db.sub(/(\?.*)$/, "#{test_worker_suffix}\\1")
+          else
+            # This check is needed because of https://github.com/rails/rails/pull/55769 adding
+            # replicas to the parallelization setup by using `include_hidden: true` which pulls in
+            # the BaseConfig. We don't want to double-suffix the database name.
+            #
+            # TODO: Ideally we should have finer-grained filtering of database configurations in Rails
+            # (other than simply hidden or not-hidden).
+            if db.end_with?(test_worker_suffix)
+              db
+            else
+              db + test_worker_suffix
+            end
+          end
+        end
+
+        # A sqlite database path can be a file path or a URI (either relative or absolute).  We
+        # can't parse it as a standard URI in all circumstances, though, see
+        # https://sqlite.org/uri.html
+        def path_for(database)
+          if database.start_with?("file:/")
+            URI.parse(database).path
+          elsif database.start_with?("file:")
+            URI.parse(database.sub(/\?.*$/, "")).opaque
+          else
+            database
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/database_configurations/base_config.rb

@@ -11,6 +11,11 @@ module ActiveRecord
         def initialize(...)
           super
           @test_worker_id = nil
+          @config_adapter = nil
+        end
+
+        def config_adapter
+          @config_adapter ||= ActiveRecord::Tenanted::DatabaseAdapter.new(self)
         end
 
         def database_tasks?
@@ -20,33 +25,19 @@ module ActiveRecord
         def database_for(tenant_name)
           tenant_name = tenant_name.to_s
 
-          validate_tenant_name(tenant_name)
+          config_adapter.validate_tenant_name(tenant_name)
 
-          path = sprintf(database, tenant: tenant_name)
+          db = sprintf(database, tenant: tenant_name)
 
           if test_worker_id
-            test_worker_path(path)
-          else
-            path
+            db = config_adapter.test_workerize(db, test_worker_id)
           end
-        end
 
-        def database_path_for(tenant_name)
-          coerce_path(database_for(tenant_name))
+          db
         end
 
         def tenants
-          glob = database_path_for("*")
-          scanner = Regexp.new(database_path_for("(.+)"))
-
-          Dir.glob(glob).map do |path|
-            result = path.scan(scanner).flatten.first
-            if result.nil?
-              warn "WARN: ActiveRecord::Tenanted: Cannot parse tenant name from filename #{path.inspect}. " \
-                   "This is a bug, please report it to https://github.com/basecamp/activerecord-tenanted/issues"
-            end
-            result
-          end
+          config_adapter.tenant_databases
         end
 
         def new_tenant_config(tenant_name)
@@ -54,7 +45,6 @@ module ActiveRecord
           config_hash = configuration_hash.dup.tap do |hash|
             hash[:tenant] = tenant_name
             hash[:database] = database_for(tenant_name)
-            hash[:database_path] = database_path_for(tenant_name)
             hash[:tenanted_config_name] = name
           end
           Tenanted::DatabaseConfigurations::TenantConfig.new(env_name, config_name, config_hash)
@@ -70,35 +60,6 @@ module ActiveRecord
         def max_connection_pools
           (configuration_hash[:max_connection_pools] || DEFAULT_MAX_CONNECTION_POOLS).to_i
         end
-
-        private
-          # A sqlite database path can be a file path or a URI (either relative or absolute).
-          # We can't parse it as a standard URI in all circumstances, though, see https://sqlite.org/uri.html
-          def coerce_path(path)
-            if path.start_with?("file:/")
-              URI.parse(path).path
-            elsif path.start_with?("file:")
-              URI.parse(path.sub(/\?.*$/, "")).opaque
-            else
-              path
-            end
-          end
-
-          def validate_tenant_name(tenant_name)
-            if tenant_name.match?(%r{[/'"`]})
-              raise BadTenantNameError, "Tenant name contains an invalid character: #{tenant_name.inspect}"
-            end
-          end
-
-          def test_worker_path(path)
-            test_worker_suffix = "_#{test_worker_id}"
-
-            if path.start_with?("file:") && path.include?("?")
-              path.sub(/(\?.*)$/, "#{test_worker_suffix}\\1")
-            else
-              path + test_worker_suffix
-            end
-          end
       end
     end
   end

data/lib/active_record/tenanted/database_configurations/tenant_config.rb

@@ -4,13 +4,25 @@ module ActiveRecord
   module Tenanted
     module DatabaseConfigurations
       class TenantConfig < ActiveRecord::DatabaseConfigurations::HashConfig
+        def initialize(...)
+          super
+          @config_adapter = nil
+        end
+
         def tenant
           configuration_hash.fetch(:tenant)
         end
 
+        def config_adapter
+          @config_adapter ||= ActiveRecord::Tenanted::DatabaseAdapter.new(self)
+        end
+
         def new_connection
-          ensure_database_directory_exists # adapter doesn't handle this if the database is a URI
-          super.tap { |conn| conn.tenant = tenant }
+          # TODO: This line can be removed once rails/rails@f1f60dc1 is in a released version of
+          # Rails, and this gem's dependency has been bumped to require that version or later.
+          config_adapter.ensure_database_directory_exists
+
+          super.tap { |connection| connection.tenant = tenant }
         end
 
         def tenanted_config_name
@@ -36,20 +48,6 @@ module ActiveRecord
             File.join(db_dir, "#{tenanted_config_name}_schema_cache.yml")
           end
         end
-
-        def database_path
-          configuration_hash[:database_path]
-        end
-
-        private
-          def ensure_database_directory_exists
-            return unless database_path
-
-            database_dir = File.dirname(database_path)
-            unless File.directory?(database_dir)
-              FileUtils.mkdir_p(database_dir)
-            end
-          end
       end
     end
   end

data/lib/active_record/tenanted/database_tasks.rb

@@ -1,58 +1,63 @@
 # frozen_string_literal: true
 
+require "rake"
+
 module ActiveRecord
   module Tenanted
-    module DatabaseTasks # :nodoc:
-      extend self
-
-      def migrate_all
-        raise ArgumentError, "Could not find a tenanted database" unless root_config = root_database_config
+    class DatabaseTasks # :nodoc:
+      include Rake::DSL
 
-        tenants = root_config.tenants.presence || [ get_current_tenant ].compact
-        tenants.each do |tenant|
-          tenant_config = root_config.new_tenant_config(tenant)
-          migrate(tenant_config)
+      class << self
+        def verbose?
+          ActiveRecord::Tasks::DatabaseTasks.send(:verbose?)
         end
       end
 
-      def migrate_tenant(tenant_name = set_current_tenant)
-        raise ArgumentError, "Could not find a tenanted database" unless root_config = root_database_config
+      attr_reader :config
+
+      def initialize(config)
+        unless config.is_a?(ActiveRecord::Tenanted::DatabaseConfigurations::BaseConfig)
+          raise TypeError, "Argument must be an instance of ActiveRecord::Tenanted::DatabaseConfigurations::BaseConfig"
+        end
+        @config = config
+      end
 
-        tenant_config = root_config.new_tenant_config(tenant_name)
+      def migrate_all
+        tenants.each do |tenant|
+          migrate_tenant(tenant)
+        end
+      end
 
-        migrate(tenant_config)
+      def migrate_tenant(tenant = set_current_tenant)
+        db_config = config.new_tenant_config(tenant)
+        migrate(db_config)
       end
 
       def drop_all
-        raise ArgumentError, "Could not find a tenanted database" unless root_config = root_database_config
-
-        root_config.tenants.each do |tenant|
-          # NOTE: This is obviously a sqlite-specific implementation.
-          # TODO: Create a `drop_database` method upstream in the sqlite3 adapter, and call it.
-          #       Then this would delegate to the adapter and become adapter-agnostic.
-          root_config.database_path_for(tenant).tap do |path|
-            FileUtils.rm(path)
-            $stdout.puts "Dropped database '#{path}'" if verbose?
-          end
+        tenants.each do |tenant|
+          drop_tenant(tenant)
         end
       end
 
-      def root_database_config
-        db_configs = ActiveRecord::Base.configurations.configs_for(
-          env_name: ActiveRecord::Tasks::DatabaseTasks.env,
-          include_hidden: true
-        )
-        db_configs.detect { |c| c.configuration_hash[:tenanted] }
+      def drop_tenant(tenant = set_current_tenant)
+        db_config = config.new_tenant_config(tenant)
+        db_config.config_adapter.drop_database
+        $stdout.puts "Dropped database '#{db_config.database}'" if verbose?
+      end
+
+      def tenants
+        config.tenants.presence || [ get_default_tenant ].compact
       end
 
-      def get_current_tenant
+      def get_default_tenant
+        # TODO: needs to work with multiple tenanted configs, maybe using ENV["ARTENANT_#{config.name}"]
         tenant = ENV["ARTENANT"]
 
         if tenant.present?
           $stdout.puts "Setting current tenant to #{tenant.inspect}" if verbose?
         elsif Rails.env.local?
           tenant = Rails.application.config.active_record_tenanted.default_tenant
-          $stdout.puts "Defaulting current tenant to #{tenant.inspect}" if verbose?
+          $stdout.puts "Defaulting current tenant for #{config.name.inspect} to #{tenant.inspect}" if verbose?
         else
           tenant = nil
           $stdout.puts "Cannot determine an implicit tenant: ARTENANT not set, and Rails.env is not local." if verbose?
@@ -68,7 +73,7 @@ module ActiveRecord
         end
 
         if connection_class.current_tenant.nil?
-          connection_class.current_tenant = get_current_tenant
+          connection_class.current_tenant = get_default_tenant
         else
           connection_class.current_tenant
         end
@@ -111,7 +116,49 @@ module ActiveRecord
       end
 
       def verbose?
-        ActiveRecord::Tasks::DatabaseTasks.send(:verbose?)
+        self.class.verbose?
+      end
+
+      def register_rake_tasks
+        name = config.name
+
+        desc "Migrate tenanted #{name} databases for current environment"
+        task "db:migrate:#{name}" => "load_config" do
+          verbose_was = ActiveRecord::Migration.verbose
+          ActiveRecord::Migration.verbose = ActiveRecord::Tenanted::DatabaseTasks.verbose?
+
+          tenant = ENV["ARTENANT"]
+          if tenant.present?
+            migrate_tenant(tenant)
+          else
+            migrate_all
+          end
+        ensure
+          ActiveRecord::Migration.verbose = verbose_was
+        end
+        task "db:migrate" => "db:migrate:#{name}"
+        task "db:prepare" => "db:migrate:#{name}"
+
+        desc "Drop tenanted #{name} databases for current environment"
+        task "db:drop:#{name}" => "load_config" do
+          verbose_was = ActiveRecord::Migration.verbose
+          ActiveRecord::Migration.verbose = ActiveRecord::Tenanted::DatabaseTasks.verbose?
+
+          tenant = ENV["ARTENANT"]
+          if tenant.present?
+            drop_tenant(tenant)
+          else
+            drop_all
+          end
+        ensure
+          ActiveRecord::Migration.verbose = verbose_was
+        end
+        task "db:drop" => "db:drop:#{name}"
+
+        # TODO: Rails' database tasks include "db:seed" in the tasks that "db:reset" runs.
+        desc "Drop and recreate tenanted #{name} database from its schema for the current environment"
+        task "db:reset:#{name}" => [ "db:drop:#{name}", "db:migrate:#{name}" ]
+        task "db:reset" => "db:reset:#{name}"
       end
     end
   end

data/lib/active_record/tenanted/railtie.rb

@@ -148,6 +148,10 @@ module ActiveRecord
       end
 
       config.after_initialize do
+        ActiveRecord::QueryLogs.taggings = ActiveRecord::QueryLogs.taggings.merge(
+          tenant: ->(context) { context[:connection].tenant }
+        )
+
         if defined?(Rails::Console)
           require "rails/commands/console/irb_console"
           Rails::Console::IRBConsole.prepend ActiveRecord::Tenanted::Console::IRBConsole

data/lib/active_record/tenanted/tenant.rb

@@ -13,11 +13,13 @@ module ActiveRecord
       end
 
       def cache_key
-        tenant ? "#{super}?tenant=#{tenant}" : super
+        tenant ? "#{tenant}/#{super}" : super
       end
 
       def inspect
-        tenant ? super.sub(/>$/, ", tenant=#{tenant.inspect}>") : super
+        return super unless tenant
+
+        super.sub(/\A#<\S+ /, "\\0tenant: #{tenant.inspect}, ")
       end
 
       def to_global_id(options = {})
@@ -99,10 +101,7 @@ module ActiveRecord
         end
 
         def tenant_exist?(tenant_name)
-          # this will have to be an adapter-specific implementation if we support other than sqlite
-          database_path = tenanted_root_config.database_path_for(tenant_name)
-
-          File.exist?(database_path) && !ActiveRecord::Tenanted::Mutex::Ready.locked?(database_path)
+          tenanted_root_config.new_tenant_config(tenant_name).config_adapter.database_ready?
         end
 
         def with_tenant(tenant_name, prohibit_shard_swapping: true, &block)
@@ -121,24 +120,22 @@ module ActiveRecord
 
         def create_tenant(tenant_name, if_not_exists: false, &block)
           created_db = false
-          database_path = tenanted_root_config.database_path_for(tenant_name)
+          base_config = tenanted_root_config
+          adapter = base_config.new_tenant_config(tenant_name).config_adapter
 
-          ActiveRecord::Tenanted::Mutex::Ready.lock(database_path) do
-            unless File.exist?(database_path)
-              # NOTE: This is obviously a sqlite-specific implementation.
-              # TODO: Add a `create_database` method upstream in the sqlite3 adapter, and call it.
-              #       Then this would delegate to the adapter and become adapter-agnostic.
-              FileUtils.touch(database_path)
+          adapter.acquire_ready_lock do
+            unless adapter.database_exist?
+              adapter.create_database
 
               with_tenant(tenant_name) do
                 connection_pool(schema_version_check: false)
-                ActiveRecord::Tenanted::DatabaseTasks.migrate_tenant(tenant_name)
+                ActiveRecord::Tenanted::DatabaseTasks.new(base_config).migrate_tenant(tenant_name)
               end
 
               created_db = true
             end
           rescue
-            FileUtils.rm_f(database_path)
+            adapter.drop_database
             raise
           end
 
@@ -158,10 +155,7 @@ module ActiveRecord
             end
           end
 
-          # NOTE: This is obviously a sqlite-specific implementation.
-          # TODO: Create a `drop_database` method upstream in the sqlite3 adapter, and call it.
-          #       Then this would delegate to the adapter and become adapter-agnostic.
-          FileUtils.rm_f(tenanted_root_config.database_path_for(tenant_name))
+          tenanted_root_config.new_tenant_config(tenant_name).config_adapter.drop_database
         end
 
         def tenants
@@ -211,12 +205,12 @@ module ActiveRecord
           return superclass._create_tenanted_pool unless connection_class?
 
           tenant = current_tenant
-          unless File.exist?(tenanted_root_config.database_path_for(tenant))
-            raise TenantDoesNotExistError, "The database file for tenant #{tenant.inspect} does not exist."
-          end
+          db_config = tenanted_root_config.new_tenant_config(tenant)
 
-          config = tenanted_root_config.new_tenant_config(tenant)
-          pool = establish_connection(config)
+          unless db_config.config_adapter.database_exist?
+            raise TenantDoesNotExistError, "The database for tenant #{tenant.inspect} does not exist."
+          end
+          pool = establish_connection(db_config)
 
           if schema_version_check
             pending_migrations = pool.migration_context.open.pending_migrations

data/lib/active_record/tenanted/untenanted_connection_pool.rb

@@ -28,6 +28,10 @@ module ActiveRecord
         ActiveRecord::ConnectionAdapters::BoundSchemaReflection.new(schema_reflection, self)
       end
 
+      def size
+        db_config.max_connections
+      end
+
       def lease_connection(...)
         raise Tenanted::NoTenantError, "Cannot connect to a tenanted database while untenanted (#{@model})."
       end

data/lib/active_record/tenanted/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module Tenanted
-    VERSION = "0.4.1"
+    VERSION = "0.6.0"
   end
 end

data/lib/active_record/tenanted.rb

@@ -4,6 +4,9 @@ require "active_record"
 
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem_extension(ActiveRecord)
+loader.inflector.inflect(
+  "sqlite" => "SQLite",
+)
 loader.setup
 
 module ActiveRecord
@@ -35,10 +38,22 @@ module ActiveRecord
     # Raised when the Rails integration is being invoked but has not been configured.
     class IntegrationNotConfiguredError < Error; end
 
+    # Raised when an unsupported database adapter is used.
+    class UnsupportedDatabaseError < Error; end
+
+    # Return the constantized connection class configured in `config.active_record_tenanted.connection_class`,
+    # or nil if none is configured.
     def self.connection_class
       # TODO: cache this / speed this up
       Rails.application.config.active_record_tenanted.connection_class&.constantize
     end
+
+    # Return an Array of the tenanted database configurations.
+    def self.base_configs(configurations = ActiveRecord::Base.configurations)
+      configurations
+        .configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env, include_hidden: true)
+        .select { |c| c.configuration_hash[:tenanted] }
+    end
   end
 end
 

data/lib/tasks/active_record/tenanted_tasks.rake

@@ -1,78 +1,20 @@
 # frozen_string_literal: true
 
-namespace :db do
-  desc "Migrate the database for tenant ARTENANT"
-  task "migrate:tenant" => "load_config" do
-    unless ActiveRecord::Tenanted.connection_class
-      warn "ActiveRecord::Tenanted integration is not configured via connection_class"
-      next
-    end
-
-    unless ActiveRecord::Tenanted::DatabaseTasks.root_database_config
-      warn "WARNING: No tenanted database found, skipping tenanted migration"
-    else
-      begin
-        verbose_was = ActiveRecord::Migration.verbose
-        ActiveRecord::Migration.verbose = ActiveRecord::Tenanted::DatabaseTasks.verbose?
-
-        ActiveRecord::Tenanted::DatabaseTasks.migrate_tenant
-      ensure
-        ActiveRecord::Migration.verbose = verbose_was
-      end
-    end
-  end
-
-  desc "Migrate the database for all existing tenants"
-  task "migrate:tenant:all" => "load_config" do
-    unless ActiveRecord::Tenanted.connection_class
-      warn "ActiveRecord::Tenanted integration is not configured via connection_class"
-      next
-    end
-
-    verbose_was = ActiveRecord::Migration.verbose
-    ActiveRecord::Migration.verbose = ActiveRecord::Tenanted::DatabaseTasks.verbose?
-
-    ActiveRecord::Tenanted::DatabaseTasks.migrate_all
-  ensure
-    ActiveRecord::Migration.verbose = verbose_was
-  end
-
-  desc "Drop and recreate all tenant databases from their schema for the current environment"
-  task "reset:tenant" => [ "db:drop:tenant", "db:migrate:tenant" ]
-
-  desc "Drop all tenanted databases for the current environment"
-  task "drop:tenant" => "load_config" do
-    unless ActiveRecord::Tenanted::DatabaseTasks.root_database_config
-      warn "WARNING: No tenanted database found, skipping tenanted reset"
-    else
-      begin
-        verbose_was = ActiveRecord::Migration.verbose
-        ActiveRecord::Migration.verbose = ActiveRecord::Tenanted::DatabaseTasks.verbose?
-
-        ActiveRecord::Tenanted::DatabaseTasks.drop_all
-      ensure
-        ActiveRecord::Migration.verbose = verbose_was
-      end
-    end
+# Ensure a default tenant is set for database tasks that may need it.
+desc "Set the current tenant to ARTENANT if present, else the environment default"
+task "db:tenant" => "load_config" do
+  unless ActiveRecord::Tenanted.connection_class
+    warn "ActiveRecord::Tenanted integration is not configured via connection_class"
+    next
   end
 
-  desc "Set the current tenant to ARTENANT if present, else the environment default"
-  task "tenant" => "load_config" do
-    unless ActiveRecord::Tenanted.connection_class
-      warn "ActiveRecord::Tenanted integration is not configured via connection_class"
-      next
-    end
-
-    ActiveRecord::Tenanted::DatabaseTasks.set_current_tenant
-  end
+  config = ActiveRecord::Tenanted.connection_class.connection_pool.db_config
+  ActiveRecord::Tenanted::DatabaseTasks.new(config).set_current_tenant
 end
-
-# Decorate database tasks with the tenanted version.
-task "db:migrate" => "db:migrate:tenant:all"
-task "db:prepare" => "db:migrate:tenant:all"
-task "db:reset"   => "db:reset:tenant"
-task "db:drop"    => "db:drop:tenant"
-
-# Ensure a default tenant is set for database tasks that may need it.
 task "db:fixtures:load" => "db:tenant"
 task "db:seed"          => "db:tenant"
+
+# Create tenanted rake tasks
+ActiveRecord::Tenanted.base_configs(ActiveRecord::DatabaseConfigurations.new(ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml)).each do |config|
+  ActiveRecord::Tenanted::DatabaseTasks.new(config).register_rake_tasks
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-tenanted
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Mike Dalessio
@@ -73,6 +73,8 @@ files:
 - lib/active_record/tenanted/cable_connection.rb
 - lib/active_record/tenanted/connection_adapter.rb
 - lib/active_record/tenanted/console.rb
+- lib/active_record/tenanted/database_adapter.rb
+- lib/active_record/tenanted/database_adapters/sqlite.rb
 - lib/active_record/tenanted/database_configurations.rb
 - lib/active_record/tenanted/database_configurations/base_config.rb
 - lib/active_record/tenanted/database_configurations/tenant_config.rb