activerecord-tenanted 0.1.0 → 0.2.0

data/lib/active_record/tenanted/mailer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module Mailer
+      def url_options(...)
+        super.tap do |options|
+          if ActiveRecord::Tenanted.connection_class && options.key?(:host)
+            options[:host] = sprintf(options[:host], tenant: ActiveRecord::Tenanted.connection_class.current_tenant)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/mutex.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module Mutex
+      #
+      #  This flock-based mutex is intended to hold a lock while the tenant database is in the
+      #  process of being created and migrated (i.e., "made ready").
+      #
+      #  The creation-and-migration time span is generally very short, and only happens once at the
+      #  beginning of the database file's existence. We can take advantage of these characteristics
+      #  to make sure the readiness check is cheap for the majority of the database's life.
+      #
+      #  1. The lock file is created and an advisory lock is acquired before the database file is
+      #     created.
+      #  2. Once the database migration has been completed and the database is ready, the lock is
+      #     released and the file is removed.
+      #
+      #  If the lock file exists, then a relatively expensive shared lock must be acquired to ensure
+      #  the database is ready to use. However, if the lock file does not exist (the majority of the
+      #  database's life!) then the readiness check is a cheap check for existing on the database
+      #  file.
+      #
+      class Ready
+        class << self
+          def lock(database_path)
+            path = lock_file_path(database_path)
+            FileUtils.mkdir_p(File.dirname(path))
+
+            # mode "w" to create the file if it does not exist.
+            File.open(path, "w") do |f|
+              f.flock(File::LOCK_EX) # blocking!
+              yield
+            ensure
+              File.unlink(path)
+            end
+          end
+
+          def locked?(database_path)
+            path = lock_file_path(database_path)
+
+            if File.exist?(path)
+              result = nil
+              begin
+                # mode "r" to avoid creating the file if it does not exist.
+                File.open(path, "r") do |f|
+                  result = f.flock(File::LOCK_SH | File::LOCK_NB)
+                end
+                result != 0
+              rescue Errno::ENOENT
+                # the file was deleted between the existence check and the open
+                false
+              end
+            else
+              false
+            end
+          end
+
+          def lock_file_path(database_path)
+            database_path.to_s + ".ready_lock"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/patches.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module Patches
+      # TODO: I think this is needed because there was no followup to rails/rails#46270.
+      # See rails/rails@901828f2 from that PR for background.
+      module DatabaseTasks
+        private
+          def with_temporary_pool(db_config, clobber: false)
+            original_db_config = begin
+              migration_class.connection_db_config
+            rescue ActiveRecord::ConnectionNotDefined
+              nil
+            end
+
+            begin
+              pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)
+
+              yield pool
+            ensure
+              migration_class.connection_handler.establish_connection(original_db_config, clobber: clobber) if original_db_config
+            end
+          end
+      end
+
+      # TODO: This monkey patch shouldn't be necessary after 8.1 lands and the need for a
+      # connection is removed. For details see https://github.com/rails/rails/pull/54348
+      module Attributes
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def _default_attributes # :nodoc:
+            @default_attributes ||= begin
+              # I've removed the `with_connection` block here.
+              nil_connection = nil
+              attributes_hash = columns_hash.transform_values do |column|
+                ActiveModel::Attribute.from_database(column.name, column.default, type_for_column(nil_connection, column))
+              end
+
+              attribute_set = ActiveModel::AttributeSet.new(attributes_hash)
+              apply_pending_attribute_modifications(attribute_set)
+              attribute_set
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/railtie.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    class Railtie < ::Rails::Railtie
+      config.active_record_tenanted = ActiveSupport::OrderedOptions.new
+
+      # Set this in an initializer if you're tenanting a connection class other than
+      # ApplicationRecord. This value indicates the connection class that this gem uses to integrate
+      # with a broad set of Rails subsystems, including:
+      #
+      # - Active Job
+      # - Active Storage
+      # - Action Cable
+      # - Action Dispatch middleware (Tenant Selector)
+      # - Test frameworks and fixtures
+      #
+      # Defaults to "ApplicationRecord", but this can be set to `nil` to turn off the integrations
+      # entirely.
+      config.active_record_tenanted.connection_class = "ApplicationRecord"
+
+      # Set this to a lambda that takes a request object and returns the tenant name. It's used by:
+      #
+      # - Action Dispatch middleware (Tenant Selector)
+      # - Action Cable connections
+      #
+      # Defaults to the request subdomain.
+      config.active_record_tenanted.tenant_resolver = ->(request) { request.subdomain }
+
+      # Set this to false in an initializer if you don't want Rails records to share a connection
+      # pool with the tenanted connection class.
+      #
+      # By default, this gem will configure ActionMailbox::Record, ActiveStorage::Record, and
+      # ActionText::Record to create/use tables in the database associated with the
+      # `connection_class`, and will share a connection pool with that class.
+      #
+      # This should only be turned off if your primary database configuration is not tenanted, and
+      # that is where you want Rails to create the tables for these records.
+      #
+      # Defaults to `true`.
+      config.active_record_tenanted.tenanted_rails_records = true
+
+      # Set this to control whether the Rails logger will include the tenant name in a tag in each
+      # log line.
+      #
+      # Defaults to false in development and test environments, and true in all other environments.
+      config.active_record_tenanted.log_tenant_tag = !Rails.env.local?
+
+      # Set this to override the default tenant name used in development and test environments.
+      #
+      # This is the default tenant name used by database tasks and in the Rails console. In both
+      # cases, this can be overridden at runtime by setting the `ARTENANT` environment variable.
+      #
+      # Notably, it's also the tenant name used by the testing frameworks, so you may need to set
+      # this if you have application-specific constraints on tenant names.
+      #
+      # Defaults to "development-tenant" in development and "test-tenant" in test environments.
+      config.active_record_tenanted.default_tenant = Rails.env.local? ? "#{Rails.env}-tenant" : nil
+
+      config.before_initialize do
+        Rails.application.configure do
+          if config.active_record_tenanted.connection_class.present?
+            config.middleware.use ActiveRecord::Tenanted::TenantSelector
+          end
+        end
+      end
+
+      initializer "active_record_tenanted.active_record_base" do
+        ActiveSupport.on_load(:active_record) do
+          prepend ActiveRecord::Tenanted::Base
+          ActiveRecord::Relation.prepend ActiveRecord::Tenanted::Relation
+        end
+      end
+
+      initializer("active_record_tenanted.active_record_schema_cache",
+                  before: "active_record.copy_schema_cache_config") do
+        # Rails must be able to load the schema for a tenanted model without a database connection
+        # (e.g., boot-time eager loading, or calling User.new to build a form). This gem relies on
+        # reading from the schema cache dump to do that.
+        #
+        # Rails defaults use_schema_cache_dump to true, but we explicitly re-set it here because if
+        # this is ever turned off, Rails will not work as expected.
+        config.active_record.use_schema_cache_dump = true
+
+        # The schema cache version check needs to query the database, which isn't always possible
+        # for tenanted models.
+        config.active_record.check_schema_cache_dump_version = false
+      end
+
+      initializer "active_record_tenanted.monkey_patches" do
+        ActiveSupport.on_load(:active_record) do
+          prepend ActiveRecord::Tenanted::Patches::Attributes
+          ActiveRecord::Tasks::DatabaseTasks.prepend ActiveRecord::Tenanted::Patches::DatabaseTasks
+        end
+      end
+
+      initializer "active_record_tenanted.active_job" do
+        ActiveSupport.on_load(:active_job) do
+          prepend ActiveRecord::Tenanted::Job
+        end
+      end
+
+      initializer "active_record_tenanted.action_cable_connection" do
+        ActiveSupport.on_load(:action_cable_connection) do
+          prepend ActiveRecord::Tenanted::CableConnection::Base
+        end
+      end
+
+      initializer "active_record_tenanted.global_id", after: "global_id" do
+        ::GlobalID.prepend ActiveRecord::Tenanted::GlobalId
+        ::GlobalID::Locator.use GlobalID.app, ActiveRecord::Tenanted::GlobalId::Locator.new
+      end
+
+      initializer "active_record_tenanted.active_storage", after: "active_storage.services" do
+        # TODO: Add a hook for Disk Service. Without that, there's no good way to include this
+        # module into the class before the service is initialized.
+        # As a workaround, explicitly require this file.
+        require "active_storage/service/disk_service"
+        ActiveStorage::Service::DiskService.prepend ActiveRecord::Tenanted::Storage::DiskService
+      end
+
+      initializer "active_record_tenanted.active_storage_blob" do
+        ActiveSupport.on_load(:active_storage_blob) do
+          prepend ActiveRecord::Tenanted::Storage::Blob
+        end
+      end
+
+      initializer "active_record_tenanted.active_record_connection_adapter" do
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend ActiveRecord::Tenanted::ConnectionAdapter
+        end
+      end
+
+      initializer "active_record_tenanted.action_mailer" do
+        ActiveSupport.on_load(:action_mailer) do
+          prepend ActiveRecord::Tenanted::Mailer
+        end
+      end
+
+      config.after_initialize do
+        if defined?(Rails::Console)
+          require "rails/commands/console/irb_console"
+          Rails::Console::IRBConsole.prepend ActiveRecord::Tenanted::Console::IRBConsole
+          Rails::Console::ReloadHelper.prepend ActiveRecord::Tenanted::Console::ReloadHelper
+        end
+
+        ActiveSupport.on_load(:action_mailbox_record) do
+          if Rails.application.config.active_record_tenanted.connection_class.present? &&
+             Rails.application.config.active_record_tenanted.tenanted_rails_records
+            subtenant_of Rails.application.config.active_record_tenanted.connection_class
+          end
+        end
+
+        ActiveSupport.on_load(:active_storage_record) do
+          if Rails.application.config.active_record_tenanted.connection_class.present? &&
+             Rails.application.config.active_record_tenanted.tenanted_rails_records
+            subtenant_of Rails.application.config.active_record_tenanted.connection_class
+          end
+        end
+
+        ActiveSupport.on_load(:action_text_record) do
+          if Rails.application.config.active_record_tenanted.connection_class.present? &&
+             Rails.application.config.active_record_tenanted.tenanted_rails_records
+            subtenant_of Rails.application.config.active_record_tenanted.connection_class
+          end
+        end
+
+        if Rails.env.test?
+          ActiveSupport.on_load(:active_support_test_case) do
+            prepend ActiveRecord::Tenanted::Testing::ActiveSupportTestCase
+          end
+
+          ActiveSupport.on_load(:action_dispatch_integration_test) do
+            prepend ActiveRecord::Tenanted::Testing::ActionDispatchIntegrationTest
+            ActionDispatch::Integration::Session.prepend ActiveRecord::Tenanted::Testing::ActionDispatchIntegrationSession
+          end
+
+          ActiveSupport.on_load(:action_dispatch_system_test_case) do
+            prepend ActiveRecord::Tenanted::Testing::ActionDispatchSystemTestCase
+          end
+
+          ActiveSupport.on_load(:active_record_fixtures) do
+            prepend ActiveRecord::Tenanted::Testing::ActiveRecordFixtures
+          end
+
+          ActiveSupport.on_load(:active_job_test_case) do
+            prepend ActiveRecord::Tenanted::Testing::ActiveJobTestCase
+          end
+
+          ActiveSupport.on_load(:action_cable_connection_test_case) do
+            prepend ActiveRecord::Tenanted::Testing::ActionCableTestCase
+          end
+        end
+      end
+
+      rake_tasks do
+        load File.expand_path(File.join(__dir__, "../../tasks/active_record/tenanted_tasks.rake"))
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/relation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module Relation # :nodoc:
+      def initialize(...)
+        super
+        @tenant = @model.current_tenant if @model.tenanted?
+      end
+
+      def instantiate_records(...)
+        super.tap do |records|
+          if @tenant
+            records.each do |record|
+              record.instance_variable_set(:@tenant, @tenant)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/storage.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module Storage # :nodoc:
+      module DiskService
+        def root
+          if klass = ActiveRecord::Tenanted.connection_class
+            unless tenant = klass.current_tenant
+              raise NoTenantError, "Cannot access Active Storage Disk service without a tenant"
+            end
+
+            sprintf(@root, tenant: tenant)
+          else
+            super
+          end
+        end
+
+        def path_for(key)
+          if ActiveRecord::Tenanted.connection_class
+            # TODO: this is brittle if the key isn't tenanted ... errors in folder_for:
+            #
+            #   NoMethodError undefined method '[]' for nil (NoMethodError) [ key[0..1], key[2..3] ].join("/")
+            #
+            tenant, key = key.split("/", 2)
+            File.join(root, tenant, folder_for(key), key)
+          else
+            super
+          end
+        end
+      end
+
+      module Blob
+        def key
+          self[:key] ||= if klass = ActiveRecord::Tenanted.connection_class
+            unless tenant = klass.current_tenant
+              raise NoTenantError, "Cannot generate a Blob key without a tenant"
+            end
+
+            token = self.class.generate_unique_secure_token(length: ActiveStorage::Blob::MINIMUM_TOKEN_LENGTH)
+            [ tenant, token ].join("/")
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/subtenant.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module Subtenant
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def tenanted?
+          true
+        end
+
+        def tenanted_subtenant_of
+          # TODO: cache this / speed this up
+          # but note that we should constantize as late as possible to avoid load order issues
+          klass = @tenanted_subtenant_of&.constantize || superclass.tenanted_subtenant_of
+
+          raise Error, "Class #{klass} is not tenanted" unless klass.tenanted?
+          raise Error, "Class #{klass} is not a connection class" unless klass.abstract_class?
+
+          klass
+        end
+
+        delegate :current_tenant, :connection_pool, to: :tenanted_subtenant_of
+      end
+
+      prepended do
+        prepend TenantCommon
+      end
+
+      def tenanted?
+        true
+      end
+    end
+  end
+end