acts_as_tenant 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a88c52c6d95ce10c987f520154321ae80f94def7f671e85b9a05c4c26c2bac48
-  data.tar.gz: 788a2f46cd8b2cf84cfbc8c46f6938358bac793b3c3af415c3f18df1ba9729b1
+  metadata.gz: 8891ee294c7263049d6bb44c00b66231976574ca467fbf88496510a422b751d5
+  data.tar.gz: 580108fc430c92f9f124841243e1ac2d070c7a899e011e153d94543283ff938f
 SHA512:
-  metadata.gz: 23f45a6a9f267804d7e39a90a0ba31e23eceefc8408a3f9643b86c99edeebe057f9824d36cd52d8536b664253816758351594757cb898a7fe4b93f0e09a4eb26
-  data.tar.gz: 4e1894df9535e14745dccbd83749cb9e56b2bfcca41bbf43565cb0121c778d44b3da25db27e3753173ffc93dfda95b4ff60242bcd845a47f3e6a9adfd1a1a4a5
+  metadata.gz: 5bfef7a385bdbb1d9264ef13a1f521d1538262858480c3c3869c3167a9761bba1c6a5fd02008948d04452c87acf49405eb0aa71630213f2d9a13982c32856605
+  data.tar.gz: ee45c099a0e26311071f3de62317bc9425e8c9f7deb3273220d65c446f0dbdb549840551ec903a6202a75777d2f491f3a7f1808bfa08c6432844ef48da0d1da5

data/README.md

@@ -158,14 +158,14 @@ Scoping your models
 -------------------
 
 ```ruby
-class AddAccountToUsers < ActiveRecord::Migration
+class AddAccountToProjects < ActiveRecord::Migration
   def up
-    add_column :users, :account_id, :integer
-    add_index  :users, :account_id
+    add_column :projects, :account_id, :integer
+    add_index  :projects, :account_id
   end
 end
 
-class User < ActiveRecord::Base
+class Project < ActiveRecord::Base
   acts_as_tenant(:account)
 end
 ```
@@ -197,6 +197,19 @@ Project.tasks.all #  => all tasks with account_id => 3
 
 Acts_as_tenant uses Rails' `default_scope` method to scope models. Rails 3.1 changed the way `default_scope` works in a good way. A user defined `default_scope` should integrate seamlessly with the one added by `acts_as_tenant`.
 
+Because the scoping comes from `default_scope`, queries built from the model are scoped when a tenant is set. This includes `update_all`, `delete_all` and `destroy_all`, and `insert_all` and `upsert_all` set the current tenant. These are **not** scoped or checked:
+
+* Any query when no tenant is set, unless `require_tenant` is enabled
+* Queries that remove the default scope, such as `unscoped`
+* Raw SQL, such as `find_by_sql`, `connection.execute` and `exec_query`
+* `update_column` and `update_columns`, which skip the check that prevents changing a record's tenant
+
+New records are assigned the current tenant unless they already have one. A record assigned to a different tenant fails validation, so to create records for another tenant, wrap them in `ActsAsTenant.with_tenant(other_tenant) { ... }`.
+
+`belongs_to` associations are validated against the current tenant regardless of whether they are declared before or after `acts_as_tenant`.
+
+When no tenant is set (for example in an admin panel or inside `without_tenant`), `belongs_to` associations to tenanted models are validated to belong to the same tenant as the record. Associated records without a tenant, such as global records, are allowed.
+
 ### Validating attribute uniqueness
 
 If you need to validate for uniqueness, chances are that you want to scope this validation to a tenant. You can do so by using:
@@ -259,47 +272,89 @@ ActsAsTenant.configure do |config|
 end
 ```
 
-* `config.require_tenant` when set to true will raise an ActsAsTenant::NoTenant error whenever a query is made without a tenant set.
+* `config.require_tenant` when set to true will raise an `ActsAsTenant::Errors::NoTenantSet` error whenever a query is made without a tenant set.
 
-`config.require_tenant` can also be assigned a lambda that is evaluated at run time. For example:
+`config.require_tenant` can also be assigned a lambda that is evaluated at run time. The lambda doesn't have access to the request, so store what it needs in `CurrentAttributes`, which Rails resets after each request. For example, to not require a tenant under `/admin`:
 
 ```ruby
+# app/models/current.rb
+class Current < ActiveSupport::CurrentAttributes
+  attribute :request
+end
+
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  before_action { Current.request = request }
+end
+
+# config/initializers/acts_as_tenant.rb
 ActsAsTenant.configure do |config|
   config.require_tenant = lambda do
-    if $request_env.present?
-      return false if $request_env["REQUEST_PATH"].start_with?("/admin/")
-    end
+    !Current.request&.path&.start_with?("/admin/")
   end
 end
 ```
 
-`ActsAsTenant.should_require_tenant?` is used to determine if a tenant is required in the current context, either by evaluating the lambda provided, or by returning the boolean value assigned to `config.require_tenant`.
+Outside of a request, such as in jobs or the console, `Current.request` is `nil` and a tenant is required.
 
-When using `config.require_tenant` alongside the `rails console`, a nice quality of life tweak is to set the tenant in the console session in your initializer script. For example in `config/initializers/acts_as_tenant.rb`:
+The lambda can also optionally receive the relation being queried as an argument. This is useful for finer control over tenant requirements.
+
+For example, if you wanted to require the tenant for every model except `User`, you could do the following:
 
 ```ruby
-SET_TENANT_PROC = lambda do
-  if defined?(Rails::Console)
-    puts "> ActsAsTenant.current_tenant = Account.first"
-    ActsAsTenant.current_tenant = Account.first
+ActsAsTenant.configure do |config|
+  config.require_tenant = lambda do |relation|
+    relation.klass.name != "User"
   end
 end
+```
 
+`ActsAsTenant.should_require_tenant?` is used to determine if a tenant is required in the current context, either by evaluating the lambda provided, or by returning the boolean value assigned to `config.require_tenant`. It accepts the relation as an optional argument, which is passed to the lambda as `nil` when omitted.
+
+With `require_tenant` enabled, ActiveStorage can raise `NoTenantSet` when it generates a preview or variant. After processing, Rails touches the attachment records, which loads their tenant-scoped models, and ActiveStorage requests don't set a tenant. Blobs are looked up by signed IDs, so it's safe to run these requests without a tenant:
+
+```ruby
+# config/initializers/acts_as_tenant.rb
+Rails.application.config.to_prepare do
+  ActiveStorage::Representations::BaseController.prepend_around_action do |_controller, action|
+    ActsAsTenant.without_tenant(&action)
+  end
+end
+```
+
+When using `config.require_tenant` alongside the `rails console`, a nice quality of life tweak is to set the tenant in the console session in your initializer script. For example in `config/initializers/acts_as_tenant.rb`:
+
+```ruby
 Rails.application.configure do
-  if Rails.env.development?
-    # Set the tenant to the first account in development on load
-    config.after_initialize do
-      SET_TENANT_PROC.call
+  if Rails.env.development? && defined?(Rails::Console)
+    # set the current_tenant during console startup and after calling reload!
+    # note: reload! calls the to_prepare callback twice
+    ActiveSupport::Reloader.to_prepare do
+      puts ">>> Setting ActsAsTenant.current_tenant = Account.first"
+      ActsAsTenant.current_tenant = Account.first
     end
+  end
+end
+```
+
+### Tenant change hook
+
+`config.tenant_change_hook` is called with the new tenant whenever `current_tenant` is set, and with `nil` when Rails resets it at the end of a request or job. For example, to use Postgres row-level security:
 
-    # Reset the tenant after calling 'reload!' in the console
-    ActiveSupport::Reloader.to_complete do
-      SET_TENANT_PROC.call
+```ruby
+ActsAsTenant.configure do |config|
+  config.tenant_change_hook = lambda do |tenant|
+    if tenant
+      ActiveRecord::Base.connection.execute(ActiveRecord::Base.sanitize_sql_array(["SET rls.account_id = ?", tenant.id]))
+    else
+      ActiveRecord::Base.connection.execute("RESET rls.account_id")
     end
   end
 end
 ```
 
+Always handle `nil`, otherwise the setting stays on the database connection and the next request using it runs as the previous tenant. The hook isn't called for `default_tenant` or `test_tenant`.
+
 belongs_to options
 ------------------
 
@@ -318,6 +373,32 @@ You can add the following `belongs_to` options to `acts_as_tenant`:
 
 Example: `acts_as_tenant(:account, counter_cache: true)`
 
+ActionCable
+-----------
+
+The controller helpers aren't available in ActionCable channels. Instead, find the tenant when the connection is made and set it around each command (subscribe, unsubscribe, and channel actions) with `around_command` (Rails 7.1+):
+
+```ruby
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    identified_by :current_account
+    around_command :set_current_tenant
+
+    def connect
+      self.current_account = Account.find_by(subdomain: request.subdomain) || reject_unauthorized_connection
+    end
+
+    private
+
+    def set_current_tenant(&block)
+      ActsAsTenant.with_tenant(current_account, &block)
+    end
+  end
+end
+```
+
+Setting the tenant in a channel's `before_subscribe` won't work, because Rails resets `current_tenant` after the subscription is created and before each channel action runs. Blocks passed to `stream_from` also run outside of commands, so wrap their contents in `ActsAsTenant.with_tenant(current_account) { ... }` if they query tenant-scoped models.
+
 Background Processing libraries
 -------------------------------
 
@@ -332,6 +413,18 @@ Add the following code to `config/initializers/acts_as_tenant.rb`:
 require 'acts_as_tenant/sidekiq'
 ```
 
+The tenant is set while the job runs, but not in `sidekiq_retries_exhausted` or death handlers, because Sidekiq calls them outside the middleware. The tenant is saved in the job hash, so you can set it yourself:
+
+```ruby
+sidekiq_retries_exhausted do |job, exception|
+  tenant = Account.find_by(id: job.dig("acts_as_tenant", "id"))
+
+  ActsAsTenant.with_tenant(tenant) do
+    # ...
+  end
+end
+```
+
 - DelayedJob - [acts_as_tenant-delayed_job](https://github.com/nunommc/acts_as_tenant-delayed_job)
 
 Testing
@@ -339,7 +432,7 @@ Testing
 
 If you set the `current_tenant` in your tests, make sure to clean up the tenant after each test by calling `ActsAsTenant.current_tenant = nil`. Integration tests are more difficult: manually setting the `current_tenant` value will not survive across multiple requests, even if they take place within the same test. This can result in undesired boilerplate to set the desired tenant. Moreover, the efficacy of the test can be compromised because the set `current_tenant` value will carry over into the request-response cycle.
 
-To address this issue, ActsAsTenant provides for a `test_tenant` value that can be set to allow for setup and post-request expectation testing. It should be used in conjunction with middleware that clears out this value while an integration test is processing. A typical Rails and RSpec setup might look like:
+To address this issue, ActsAsTenant provides for a `test_tenant` value that can be set to allow for setup and post-request expectation testing. It should be used in conjunction with middleware that clears out this value while an integration test is processing. `test_tenant` is only intended for request/integration tests; in model and unit tests, set `current_tenant` or use `with_tenant` instead. A typical Rails and RSpec setup might look like:
 
 ```ruby
 # test.rb
@@ -372,6 +465,21 @@ config.after(:each) do |example|
   ActsAsTenant.test_tenant = nil
 end
 ```
+
+### Jobs performed inline
+
+Rails resets `CurrentAttributes`, including `current_tenant`, after it performs a job inline ([rails/rails#49227](https://github.com/rails/rails/issues/49227)). The job runs with the tenant it was enqueued with, but the test loses its tenant afterwards when the job is performed inside a `perform_enqueued_jobs` block or with the `:inline` adapter. Call `perform_enqueued_jobs` without a block instead:
+
+```ruby
+ActsAsTenant.current_tenant = account
+ProcessOrderJob.perform_later(order)
+perform_enqueued_jobs
+
+expect(ActsAsTenant.current_tenant).to eq(account)
+```
+
+`perform_now` also keeps the tenant.
+
 Bug reports & suggested improvements
 ------------------------------------
 

data/lib/acts_as_tenant/active_job_extensions.rb

@@ -1,13 +1,30 @@
 module ActsAsTenant
   module ActiveJobExtensions
+    def self.prepended(base)
+      # Resolve the tenant inside the perform callbacks so `rescue_from`, `retry_on`
+      # and `discard_on` can handle a tenant that no longer exists.
+      base.before_perform do
+        ActsAsTenant.current_tenant = GlobalID::Locator.locate(@acts_as_tenant_global_id) if @acts_as_tenant_global_id
+      end
+    end
+
     def serialize
-      super.merge("current_tenant" => ActsAsTenant.current_tenant&.to_global_id&.to_s)
+      # A deserialized job keeps the tenant it was enqueued with, e.g. when it is retried.
+      tenant_global_id = defined?(@acts_as_tenant_global_id) ? @acts_as_tenant_global_id : ActsAsTenant.current_tenant&.to_global_id&.to_s
+      super.merge("current_tenant" => tenant_global_id)
     end
 
     def deserialize(job_data)
-      tenant_global_id = job_data.delete("current_tenant")
-      ActsAsTenant.current_tenant = tenant_global_id ? GlobalID::Locator.locate(tenant_global_id) : nil
+      @acts_as_tenant_global_id = job_data.delete("current_tenant")
       super
     end
+
+    def perform_now
+      return super unless defined?(@acts_as_tenant_global_id)
+
+      # Start without a tenant so a job enqueued without one never inherits the thread's,
+      # and restore the thread's tenant once the job is done.
+      ActsAsTenant.with_tenant(nil) { super }
+    end
   end
 end

data/lib/acts_as_tenant/configuration.rb

@@ -1,6 +1,7 @@
 module ActsAsTenant
   class Configuration
     attr_writer :require_tenant, :pkey
+    attr_accessor :tenant_change_hook
 
     def require_tenant
       @require_tenant ||= false

data/lib/acts_as_tenant/controller_extensions/filter.rb

@@ -1,8 +1,6 @@
 module ActsAsTenant
   module ControllerExtensions
     module Filter
-      extend ActiveSupport::Concern
-
       private
 
       def set_current_tenant(current_tenant_object)

data/lib/acts_as_tenant/controller_extensions/subdomain.rb

@@ -11,7 +11,7 @@ module ActsAsTenant
       private
 
       def find_tenant_by_subdomain
-        if (subdomain = request.subdomains.send(subdomain_lookup))
+        if (subdomain = request.subdomains.public_send(subdomain_lookup))
           ActsAsTenant.current_tenant = tenant_class.where(tenant_column => subdomain.downcase).first
         end
       end

data/lib/acts_as_tenant/controller_extensions/subdomain_or_domain.rb

@@ -11,7 +11,7 @@ module ActsAsTenant
       private
 
       def find_tenant_by_subdomain_or_domain
-        subdomain = request.subdomains.send(subdomain_lookup)
+        subdomain = request.subdomains.public_send(subdomain_lookup)
         query = subdomain.present? ? {tenant_primary_column => subdomain.downcase} : {tenant_second_column => request.domain.downcase}
         ActsAsTenant.current_tenant = tenant_class.where(query).first
       end

data/lib/acts_as_tenant/controller_extensions.rb

@@ -15,7 +15,6 @@ module ActsAsTenant
       self.subdomain_lookup = subdomain_lookup
     end
 
-    # 01/27/2014 Christian Yerena / @preth00nker
     # this method adds the possibility of use the domain as a possible second argument to find
     # the current_tenant.
     def set_current_tenant_by_subdomain_or_domain(tenant = :account, primary_column = :subdomain, second_column = :domain, subdomain_lookup: :last)
@@ -28,7 +27,7 @@ module ActsAsTenant
     end
 
     # This method sets up a method that allows manual setting of the current_tenant. This method should
-    # be used in a before_action. In addition, a helper is setup that returns the current_tenant
+    # be used in a before_action.
     def set_current_tenant_through_filter
       include Filter
     end

data/lib/acts_as_tenant/model_extensions.rb

@@ -5,35 +5,48 @@ module ActsAsTenant
     class_methods do
       def acts_as_tenant(tenant = :account, scope = nil, **options)
         ActsAsTenant.set_tenant_klass(tenant)
-        ActsAsTenant.mutable_tenant!(false)
 
         ActsAsTenant.add_global_record_model(self) if options[:has_global_records]
 
         # Create the association
         valid_options = options.slice(:foreign_key, :class_name, :inverse_of, :optional, :primary_key, :counter_cache, :polymorphic, :touch)
-        fkey = valid_options[:foreign_key] || ActsAsTenant.fkey
         pkey = valid_options[:primary_key] || ActsAsTenant.pkey
-        polymorphic_type = valid_options[:foreign_type] || ActsAsTenant.polymorphic_type
         belongs_to tenant, scope, **valid_options
 
-        default_scope lambda {
-          if ActsAsTenant.should_require_tenant? && ActsAsTenant.current_tenant.nil? && !ActsAsTenant.unscoped?
-            raise ActsAsTenant::Errors::NoTenantSet
+        tenant_reflection = reflect_on_association(tenant)
+        fkey = tenant_reflection.foreign_key.to_sym
+        polymorphic_type = tenant_reflection.foreign_type&.to_sym
+
+        # Polymorphic tenants are stored with polymorphic_name, like Rails does. Records saved before
+        # that used the class name, which differs for STI tenants, so match both when scoping.
+        # An OR is used because Rails 6.0 would assign an IN condition to new records as their type.
+        polymorphic_condition = lambda do |current_tenant|
+          polymorphic_name = current_tenant.class.polymorphic_name
+          class_name = current_tenant.class.name
+
+          if polymorphic_name == class_name
+            {polymorphic_type => polymorphic_name}
+          else
+            arel_table[polymorphic_type].eq(polymorphic_name).or(arel_table[polymorphic_type].eq(class_name))
           end
+        end
+
+        default_scope lambda {
+          current_tenant = ActsAsTenant.current_tenant
 
-          if ActsAsTenant.current_tenant
-            keys = [ActsAsTenant.current_tenant.send(pkey)].compact
+          if current_tenant
+            keys = [current_tenant.public_send(pkey)].compact
             keys.push(nil) if options[:has_global_records]
 
-            if options[:through]
-              query_criteria = {options[:through] => {fkey.to_sym => keys}}
-              query_criteria[polymorphic_type.to_sym] = ActsAsTenant.current_tenant.class.to_s if options[:polymorphic]
-              joins(options[:through]).where(query_criteria)
+            relation = if options[:through]
+              joins(options[:through]).where(options[:through] => {fkey => keys})
             else
-              query_criteria = {fkey.to_sym => keys}
-              query_criteria[polymorphic_type.to_sym] = ActsAsTenant.current_tenant.class.to_s if options[:polymorphic]
-              where(query_criteria)
+              where(fkey => keys)
             end
+
+            options[:polymorphic] ? relation.where(polymorphic_condition.call(current_tenant)) : relation
+          elsif !ActsAsTenant.unscoped? && ActsAsTenant.should_require_tenant?(self)
+            raise ActsAsTenant::Errors::NoTenantSet
           else
             all
           end
@@ -43,61 +56,112 @@ module ActsAsTenant
         # - new instances should have the tenant set
         # - validate that associations belong to the tenant, currently only for belongs_to
         #
+        # New records without a tenant get the current tenant. A record assigned to
+        # another tenant keeps it and fails the validation below.
         before_validation proc { |m|
-          if ActsAsTenant.current_tenant
-            if options[:polymorphic]
-              m.send("#{fkey}=".to_sym, ActsAsTenant.current_tenant.class.to_s) if m.send(fkey.to_s).nil?
-              m.send("#{polymorphic_type}=".to_sym, ActsAsTenant.current_tenant.class.to_s) if m.send(polymorphic_type.to_s).nil?
+          if (current_tenant = ActsAsTenant.current_tenant)
+            m.public_send(:"#{fkey}=", current_tenant.public_send(pkey)) if m.public_send(fkey).nil?
+            m.public_send(:"#{polymorphic_type}=", current_tenant.class.polymorphic_name) if options[:polymorphic] && m.public_send(polymorphic_type).nil?
+          end
+        }, on: :create
+
+        # Returns [tenant id, tenant class] for a record, or nil if it has no tenant.
+        # Classes are normalized with polymorphic_name so STI tenants compare equal.
+        tenant_identity = lambda do |model|
+          reflection = model.class.reflect_on_association(tenant)
+          id = model.read_attribute(reflection.foreign_key) if reflection
+
+          if id
+            type = if reflection.polymorphic?
+              stored_type = model.read_attribute(reflection.foreign_type)
+              stored_type&.safe_constantize&.polymorphic_name || stored_type
             else
-              m.send "#{fkey}=".to_sym, ActsAsTenant.current_tenant.send(pkey)
+              reflection.klass.polymorphic_name
             end
+            [id, type]
           end
-        }, on: :create
+        end
+
+        # Without a current tenant the association lookup isn't scoped, so compare the tenants directly
+        tenant_mismatch = lambda do |record, associated|
+          if ActsAsTenant.current_tenant.nil? && associated.class.respond_to?(:scoped_by_tenant?)
+            record_tenant = tenant_identity.call(record)
+            associated_tenant = tenant_identity.call(associated)
 
-        polymorphic_foreign_keys = reflect_on_all_associations(:belongs_to).select { |a|
-          a.options[:polymorphic]
-        }.map { |a| a.foreign_key }
-
-        reflect_on_all_associations(:belongs_to).each do |a|
-          unless a == reflect_on_association(tenant) || polymorphic_foreign_keys.include?(a.foreign_key)
-            validates_each a.foreign_key.to_sym do |record, attr, value|
-              next if value.nil?
-              next unless record.will_save_change_to_attribute?(attr)
-
-              primary_key = if a.respond_to?(:active_record_primary_key)
-                a.active_record_primary_key
-              else
-                a.primary_key
-              end.to_sym
-              scope = a.scope || ->(relation) { relation }
-              record.errors.add attr, "association is invalid [ActsAsTenant]" unless a.klass.class_eval(&scope).where(primary_key => value).any?
+            record_tenant && associated_tenant && record_tenant != associated_tenant
+          end
+        end
+
+        # Records must belong to the current tenant, matching what the default scope would find
+        validate do |record|
+          current_tenant = ActsAsTenant.current_tenant
+          next unless current_tenant
+
+          tenant_attributes = [fkey, polymorphic_type].compact
+          next unless record.new_record? || tenant_attributes.any? { |attr| record.will_save_change_to_attribute?(attr) }
+
+          record_tenant = tenant_identity.call(record)
+          next if record_tenant.nil?
+
+          record_id, record_type = record_tenant
+          matches = record_id.to_s == current_tenant.public_send(pkey).to_s
+          matches &&= record_type == current_tenant.class.polymorphic_name if options[:polymorphic]
+
+          record.errors.add(fkey, "must be the current tenant [ActsAsTenant]") unless matches
+        end
+
+        # Associations are looked up at validation time so belongs_to associations
+        # declared after acts_as_tenant are validated too
+        validate do |record|
+          associations = record.class.reflect_on_all_associations(:belongs_to)
+          polymorphic_foreign_keys = associations.select(&:polymorphic?).map(&:foreign_key)
+
+          associations.each do |a|
+            attr = a.foreign_key.to_sym
+            next unless record.will_save_change_to_attribute?(attr)
+            next if a.name == tenant.to_sym || polymorphic_foreign_keys.include?(a.foreign_key)
+
+            value = record.read_attribute_for_validation(attr)
+            next if value.nil?
+
+            relation = a.scope ? a.klass.class_eval(&a.scope) : a.klass
+            associated = relation.find_by(a.association_primary_key => value)
+
+            if associated.nil? || tenant_mismatch.call(record, associated)
+              record.errors.add attr, "association is invalid [ActsAsTenant]"
             end
           end
         end
 
-        # Dynamically generate the following methods:
-        # - Rewrite the accessors to make tenant immutable
-        # - Add an override to prevent unnecessary db hits
-        # - Add a helper method to verify if a model has been scoped by AaT
+        # Tenant writers raise if the tenant changes on a persisted record
         to_include = Module.new {
-          define_method "#{fkey}=" do |integer|
-            write_attribute(fkey.to_s, integer)
-            raise ActsAsTenant::Errors::TenantIsImmutable if !ActsAsTenant.mutable_tenant? && tenant_modified?
+          define_method :"#{fkey}=" do |integer|
+            write_attribute(fkey, integer)
+            raise_if_tenant_changed
             integer
           end
 
-          define_method "#{ActsAsTenant.tenant_klass}=" do |model|
+          define_method :"#{tenant}=" do |model|
             super(model)
-            raise ActsAsTenant::Errors::TenantIsImmutable if !ActsAsTenant.mutable_tenant? && tenant_modified?
+            raise_if_tenant_changed
             model
           end
 
+          define_method :raise_if_tenant_changed do
+            raise ActsAsTenant::Errors::TenantIsImmutable if !ActsAsTenant.mutable_tenant? && tenant_modified?
+          end
+          private :raise_if_tenant_changed
+
           define_method :tenant_modified? do
             will_save_change_to_attribute?(fkey) && persisted? && attribute_in_database(fkey).present?
           end
         }
         include to_include
 
+        # Stored per model since ActsAsTenant.tenant_klass is whichever model called acts_as_tenant last
+        class_attribute :acts_as_tenant_foreign_key, instance_accessor: false
+        self.acts_as_tenant_foreign_key = fkey
+
         class << self
           def scoped_by_tenant?
             true
@@ -105,10 +169,11 @@ module ActsAsTenant
         end
       end
 
-      def validates_uniqueness_to_tenant(fields, args = {})
+      def validates_uniqueness_to_tenant(*fields)
+        args = fields.extract_options!
         raise ActsAsTenant::Errors::ModelNotScopedByTenant unless respond_to?(:scoped_by_tenant?)
 
-        fkey = reflect_on_association(ActsAsTenant.tenant_klass).foreign_key
+        fkey = acts_as_tenant_foreign_key
 
         validation_args = args.deep_dup
         validation_args[:scope] = if args[:scope]
@@ -118,25 +183,26 @@ module ActsAsTenant
         end
 
         # validating within tenant scope
-        validates_uniqueness_of(fields, validation_args)
+        validates_uniqueness_of(*fields, validation_args)
 
         if ActsAsTenant.models_with_global_records.include?(self)
           arg_if = args.delete(:if)
           arg_condition = args.delete(:conditions)
+          arg_if_passes = ->(instance) { arg_if.blank? || arg_if.call(instance) }
 
           # if tenant is not set (instance is global) - validating globally
           global_validation_args = args.merge(
-            if: ->(instance) { instance[fkey].blank? && (arg_if.blank? || arg_if.call(instance)) }
+            if: ->(instance) { instance[fkey].blank? && arg_if_passes.call(instance) }
           )
-          validates_uniqueness_of(fields, global_validation_args)
+          validates_uniqueness_of(*fields, global_validation_args)
 
           # if tenant is set (instance is not global) and records can be global - validating within records with blank tenant
-          blank_tenant_validation_args = args.merge({
+          blank_tenant_validation_args = args.merge(
             conditions: -> { arg_condition.blank? ? where(fkey => nil) : arg_condition.call.where(fkey => nil) },
-            if: ->(instance) { instance[fkey].present? && (arg_if.blank? || arg_if.call(instance)) }
-          })
+            if: ->(instance) { instance[fkey].present? && arg_if_passes.call(instance) }
+          )
 
-          validates_uniqueness_of(fields, blank_tenant_validation_args)
+          validates_uniqueness_of(*fields, blank_tenant_validation_args)
         end
       end
     end

data/lib/acts_as_tenant/sidekiq.rb

@@ -10,12 +10,8 @@ module ActsAsTenant::Sidekiq
     include Sidekiq::ClientMiddleware if sidekiq_7_and_up?
 
     def call(worker_class, msg, queue, redis_pool)
-      if ActsAsTenant.current_tenant.present?
-        msg["acts_as_tenant"] ||=
-          {
-            "class" => ActsAsTenant.current_tenant.class.name,
-            "id" => ActsAsTenant.current_tenant.id
-          }
+      if (tenant = ActsAsTenant.current_tenant)
+        msg["acts_as_tenant"] ||= {"class" => tenant.class.name, "id" => tenant.id}
       end
 
       yield
@@ -31,9 +27,7 @@ module ActsAsTenant::Sidekiq
         klass = msg["acts_as_tenant"]["class"].constantize
         id = msg["acts_as_tenant"]["id"]
         account = klass.class_eval(&ActsAsTenant.configuration.job_scope).find(id)
-        ActsAsTenant.with_tenant account do
-          yield
-        end
+        ActsAsTenant.with_tenant(account) { yield }
       else
         yield
       end
@@ -52,9 +46,7 @@ Sidekiq.configure_server do |config|
     chain.add ActsAsTenant::Sidekiq::Client
   end
   config.server_middleware do |chain|
-    if defined?(Sidekiq::Middleware::Server::RetryJobs)
-      chain.insert_before Sidekiq::Middleware::Server::RetryJobs, ActsAsTenant::Sidekiq::Server
-    elsif defined?(Sidekiq::Batch::Server)
+    if defined?(Sidekiq::Batch::Server)
       chain.insert_before Sidekiq::Batch::Server, ActsAsTenant::Sidekiq::Server
     else
       chain.add ActsAsTenant::Sidekiq::Server

data/lib/acts_as_tenant/version.rb

@@ -1,3 +1,3 @@
 module ActsAsTenant
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/acts_as_tenant.rb

@@ -12,10 +12,16 @@ module ActsAsTenant
   @@configuration = nil
   @@tenant_klass = nil
   @@models_with_global_records = []
-  @@mutable_tenant = false
 
   class Current < ActiveSupport::CurrentAttributes
-    attribute :current_tenant, :acts_as_tenant_unscoped
+    attribute :current_tenant, :acts_as_tenant_unscoped, :acts_as_tenant_mutable
+
+    # Rails resets attributes directly at the end of a request or job, bypassing the writer below
+    resets { ActsAsTenant.configuration.tenant_change_hook&.call(nil) }
+
+    def current_tenant=(tenant)
+      super.tap { ActsAsTenant.configuration.tenant_change_hook&.call(tenant) }
+    end
   end
 
   class << self
@@ -93,59 +99,41 @@ module ActsAsTenant
   end
 
   def self.mutable_tenant!(toggle)
-    @@mutable_tenant = toggle
+    Current.acts_as_tenant_mutable = toggle
   end
 
   def self.mutable_tenant?
-    @@mutable_tenant
+    !!Current.acts_as_tenant_mutable
   end
 
   def self.with_tenant(tenant, &block)
-    if block.nil?
-      raise ArgumentError, "block required"
-    end
+    raise ArgumentError, "block required" if block.nil?
 
-    old_tenant = current_tenant
-    self.current_tenant = tenant
-    value = block.call
-    value
-  ensure
-    self.current_tenant = old_tenant
+    Current.set(current_tenant: tenant, &block)
   end
 
   def self.without_tenant(&block)
-    if block.nil?
-      raise ArgumentError, "block required"
-    end
+    raise ArgumentError, "block required" if block.nil?
 
-    old_tenant = current_tenant
     old_test_tenant = test_tenant
-    old_unscoped = unscoped
-
-    self.current_tenant = nil
     self.test_tenant = nil
-    self.unscoped = true
-    value = block.call
-    value
-  ensure
-    self.current_tenant = old_tenant
-    self.test_tenant = old_test_tenant
-    self.unscoped = old_unscoped
+    begin
+      Current.set(current_tenant: nil, acts_as_tenant_unscoped: true, &block)
+    ensure
+      self.test_tenant = old_test_tenant
+    end
   end
 
   def self.with_mutable_tenant(&block)
-    ActsAsTenant.mutable_tenant!(true)
-    without_tenant(&block)
-  ensure
-    ActsAsTenant.mutable_tenant!(false)
+    Current.set(acts_as_tenant_mutable: true) { without_tenant(&block) }
   end
 
-  def self.should_require_tenant?
-    if configuration.require_tenant.respond_to?(:call)
-      !!configuration.require_tenant.call
-    else
-      !!configuration.require_tenant
-    end
+  def self.should_require_tenant?(relation = nil)
+    config = configuration.require_tenant
+    return !!config unless config.respond_to?(:call)
+
+    arity = config.respond_to?(:arity) ? config.arity : config.method(:call).arity
+    arity.zero? ? !!config.call : !!config.call(relation)
   end
 end
 

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_tenant
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Erwin Matthijssen
 - Chris Oliver
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -51,9 +50,10 @@ files:
 - lib/acts_as_tenant/test_tenant_middleware.rb
 - lib/acts_as_tenant/version.rb
 homepage: https://github.com/ErwinM/acts_as_tenant
-licenses: []
-metadata: {}
-post_install_message:
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -68,8 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key:
+rubygems_version: 4.0.21
 specification_version: 4
 summary: Add multi-tenancy to Rails applications using a shared db strategy
 test_files: []