acts_as_multi_tenant 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f9bec876a4f3fa00936a46c89514da147bd257c064e40752122e0270ee45137
-  data.tar.gz: 4e37d1398746befc54de7d1a42a102f668aadf4b95e80ec853d8a960f83bfd70
+  metadata.gz: 839e8371c9bef7b4192ed3ed8a724358185dadefd207455495c74417a582eb46
+  data.tar.gz: fb6107209c01fef24a0e7ab46ca5f627916f76fcd04263e197f465a6d2962c87
 SHA512:
-  metadata.gz: df02d6f79a2f0abe627ae2319acb6930cc8cd4043cec326b34da71ca5f704b64ab64c38a5e940bf342d6f39310463f3ca6e2eeb047481af3282052e57cdec9fe
-  data.tar.gz: fcd53a8bcb9bff89f16a5523d9175ba5ed6dbc0bb6399dd2a16312f5c4fbdeb867d6ff4373bf95dc28e6f3ca84ce8a79d8d955cd2432939dbf5a3ad686c5651a
+  metadata.gz: 781cce611831503923b1a4351c5bdf7f70f26e5f280b8d99489d4296f73d36b9511add58df9348fe06c8e1526b9b90a2b1f63b81810a5c3ac23e3e3f628038a7
+  data.tar.gz: d6c1d709cc05cf8de12eea5eb2cea0aa1703cd5210b06c06485f0d3e272f764c56fb56462146fc3545545dd9fab613de014a4e7aaa27f18a785f5bad3a0c3967

data/README.md

@@ -1,6 +1,6 @@
 # acts_as_multi_tenant
 
-Keep multiple tenants in a single ActiveRecord database, and keep their data separate. Let's say the `Client` AR model represents your "tenants". Some Rack middleware will keep track of the "current" client in the request cycle, which will automatically filter *all ActiveRecord queries* by that client, and automatically associate new records to the client as well.
+Keep multiple tenants in a single ActiveRecord database, and keep their data separate. Let's say the `Client` AR model represents your "tenants". Rack middleware will keep track of the "current" client in the request cycle which will automatically filter *all ActiveRecord queries* by that client. New records will automatically be associated to that client as well.
 
 There are 3 main components:
 
@@ -10,7 +10,7 @@ There are 3 main components:
 
 ## MultiTenant::Middleware
 
-Add the middleware in **config.ru**, or wherever you add middleware.
+Add the middleware in **config.ru** or wherever you add middleware.
 
 ```ruby
 use MultiTenant::Middleware,
@@ -115,6 +115,27 @@ end
 License.current == Client.current.license
 ```
 
+## Multiple current tenants
+
+Some applications may need to allow multiple current tenants at once. For example, a single user account may have access to multiple clients. `acts_as_multi_tenant` supports this with the `current: :multiple` option. When this is set, `Client.current` will be an array of clients. Queries will be filtered to ANY of those clients.
+
+```ruby
+class Client < ActiveRecord::Base
+  acts_as_tenant using: :code, current: :multiple
+end
+```
+
+When you add your middleware, your `identifier` option must also return an array:
+
+```ruby
+use MultiTenant::Middleware,
+  model: -> { Client.active },
+
+  identifier: ->(req) {
+    req.params["clients"] || []
+  }
+```
+
 ## Testing
 
     bundle install

data/lib/acts_as_multi_tenant.rb

@@ -5,3 +5,11 @@ require_relative 'multi_tenant/proxies_to_tenant'
 require_relative 'multi_tenant/belongs_to_tenant'
 require_relative 'multi_tenant/belongs_to_tenant_through'
 require_relative 'multi_tenant/middleware'
+
+module MultiTenant
+  module Impl
+    NotImplemented = Class.new(StandardError)
+    autoload :SingleCurrent, 'multi_tenant/impl/single_current'
+    autoload :MultipleCurrent, 'multi_tenant/impl/multiple_current'
+  end
+end

data/lib/multi_tenant/acts_as_tenant.rb

@@ -9,13 +9,22 @@ module MultiTenant
     #
     # Use this ActiveRecord model as the tenant source.
     #
+    # The "current" option allows you to specify whether Client.current is a single record (the default) or an array of records.
+    #
     # @param using [String] (optional) column that contains the unique lookup identifier. Defaults to :code.
+    # @param current [Symbol] :single | :multiple
     #
-    def acts_as_tenant(using: :code)
-      cattr_accessor :tenant_identifier, :tenant_thread_var
+    def acts_as_tenant(using: :code, current: :single)
+      cattr_accessor :tenant_identifier, :tenant_thread_var, :multi_tenant_impl
       self.tenant_identifier = using
       self.tenant_thread_var = "current_tenant_#{object_id}".freeze # allows there to be multiple tenant classes
+      self.multi_tenant_impl = case current
+                               when :single then MultiTenant::Impl::SingleCurrent.new(self)
+                               when :multiple then MultiTenant::Impl::MultipleCurrent.new(self)
+                               else raise ArgumentError, "Unknown current option '#{current}'"
+                               end
       self.extend MultiTenant::ActsAsTenant::ClassMethods
+      self.extend self.multi_tenant_impl.acts_as_tenant_class_methods
     end
 
     #
@@ -60,13 +69,7 @@ module MultiTenant
       # @param record_or_identifier the record or the identifier in the 'tenant_identifier' column.
       #
       def current=(record_or_identifier)
-        obj = if record_or_identifier.is_a? self
-                record_or_identifier
-              elsif record_or_identifier
-                where({tenant_identifier => record_or_identifier}).first
-              else
-                nil
-              end
+        obj = resolve_tenant record_or_identifier
         Thread.current.thread_variable_set tenant_thread_var, obj
       end
 
@@ -102,7 +105,7 @@ module MultiTenant
       #
       def without_tenant
         old_current = self.current
-        self.current = nil
+        self.current = resolve_tenant nil
         yield if block_given?
       ensure
         self.current = old_current

data/lib/multi_tenant/belongs_to_tenant.rb

@@ -27,17 +27,10 @@ module MultiTenant
       self.tenant_foreign_key = reflection.foreign_key.to_sym
       self.tenant_primary_key = reflection.association_primary_key.to_sym
 
-      before_validation :assign_to_tenant
-      validates_presence_of tenant_foreign_key
-
-      self.class_eval do
-        include MultiTenant::BelongsToTenant::InstanceMethods
+      include tenant_class.multi_tenant_impl.belongs_to_tenant_instance_methods
+      default_scope(&tenant_class.multi_tenant_impl.belongs_to_tenant_default_scope(self))
 
-        default_scope {
-          current = tenant_class.current
-          current ? where({tenant_foreign_key => current.send(tenant_primary_key)}) : where('1=1')
-        }
-      end
+      validates_presence_of tenant_foreign_key
     end
 
     #
@@ -48,22 +41,6 @@ module MultiTenant
     def belongs_to_tenant?
       respond_to? :tenant_class
     end
-
-    #
-    # Instance methods given to tenant-owned models.
-    #
-    module InstanceMethods
-      private
-
-      #
-      # Assign this model to the current tenant (if any)
-      #
-      def assign_to_tenant
-        if self.class.tenant_class.current and send(self.class.tenant_foreign_key).blank?
-          send "#{self.class.tenant_foreign_key}=", self.class.tenant_class.current.send(self.class.tenant_primary_key)
-        end
-      end
-    end
   end
 end
 

data/lib/multi_tenant/belongs_to_tenant_through.rb

@@ -22,17 +22,8 @@ module MultiTenant
       cattr_accessor :delegate_class
       self.delegate_class = ref.klass
 
-      self.class_eval do
-        default_scope {
-          tenant = delegate_class.tenant_class.current
-          next where('1=1') if tenant.nil?
-
-          # Using straight sql so we can JOIN against two columns. Otherwise one must go into "WHERE", and Arel would mistakenly apply it to UPDATEs and DELETEs.
-          quoted_tenant_id = connection.quote tenant.send delegate_class.tenant_primary_key
-          joins("INNER JOIN #{ref.klass.table_name} ON #{ref.klass.table_name}.#{ref.foreign_key}=#{table_name}.#{ref.association_primary_key} AND #{ref.klass.table_name}.#{ref.klass.tenant_foreign_key}=#{quoted_tenant_id}").
-            readonly(false) # using "joins" makes records readonly, which we don't want
-        }
-      end
+      impl = self.delegate_class.tenant_class.multi_tenant_impl
+      default_scope(&impl.belongs_to_tenant_through_default_scope(self, ref))
     end
 
     #

data/lib/multi_tenant/impl/multiple_current.rb

@@ -0,0 +1,104 @@
+module MultiTenant
+  module Impl
+    #
+    # An implementation where Tenant.current is an array of tenants. All queries will be scoped to ANY of these
+    # tenants.
+    #
+    class MultipleCurrent
+      attr_reader :tenant_class
+
+      def initialize(tenant_class)
+        @tenant_class = tenant_class
+      end
+
+      def acts_as_tenant_class_methods
+        ActsAsTenantClassMethods
+      end
+
+      def belongs_to_tenant_instance_methods
+        BelongsToTenantInstanceMethods
+      end
+
+      def belongs_to_tenant_default_scope(model)
+        -> {
+          current = tenant_class.current.map(&model.tenant_primary_key)
+          current.any? ? model.where({model.tenant_foreign_key => current}) : model.where('1=1')
+        }
+      end
+
+      def belongs_to_tenant_through_default_scope(model, ref)
+        -> {
+          tenants = model.delegate_class.tenant_class.current
+          next model.where('1=1') if tenants.empty?
+
+          # Using straight sql so we can JOIN against two columns. Otherwise one must go into "WHERE", and Arel would apply it to UPDATEs and DELETEs.
+          quoted_tenant_ids = tenants.map { |t| model.connection.quote t.send model.delegate_class.tenant_primary_key }
+          model.joins("INNER JOIN #{ref.klass.table_name} ON #{ref.klass.table_name}.#{ref.foreign_key}=#{model.table_name}.#{ref.association_primary_key} AND #{ref.klass.table_name}.#{ref.klass.tenant_foreign_key} IN (#{quoted_tenant_ids.join(',')})").
+            distinct.
+            readonly(false) # using "joins" makes records readonly, which we don't want
+        }
+      end
+
+      def proxies_to_tenant_class_methods(_ref)
+        raise MultiTenant::Impl::NotImplemented, "`proxies_to_tenant` is not currently supported for impl `:multiple`."
+      end
+
+      def matching_globals(records_or_identifiers, globals)
+        records_or_identifiers.reduce([]) { |a, rec_or_id|
+          id = rec_or_id.is_a?(tenant_class) ? rec_or_id.send(tenant_class.tenant_identifier) : rec_or_id
+          a << globals[id] if globals.has_key? id
+          a
+        }
+      end
+
+      #
+      # Class methods given to the tenant model.
+      #
+      module ActsAsTenantClassMethods
+        def self.extended(model)
+          model.current = []
+        end
+
+        def current?
+          !current.nil? && current.any?
+        end
+
+        def resolve_tenant(records_or_identifiers)
+          if records_or_identifiers.nil?
+            []
+          elsif records_or_identifiers.any? { |x| x.is_a? self }
+            records_or_identifiers
+          elsif records_or_identifiers.any?
+            where({tenant_identifier => records_or_identifiers}).to_a
+          else
+            []
+          end
+        end
+      end
+
+      #
+      # Instance methods given to tenant-owned models.
+      #
+      module BelongsToTenantInstanceMethods
+        def self.included(model)
+          model.class_eval do
+            validate :ensure_assigned_to_current_tenants
+          end
+        end
+
+        private
+
+        #
+        # If the tenant_id is set, make sure it's one of the current ones.
+        #
+        def ensure_assigned_to_current_tenants
+          _tenants = self.class.tenant_class.current.map(&:id)
+          _tenant_id = send self.class.tenant_foreign_key
+          if _tenants.any? and _tenant_id.present? and !_tenants.include?(_tenant_id.to_s)
+            errors.add(self.class.tenant_foreign_key, "is incorrect")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multi_tenant/impl/single_current.rb

@@ -0,0 +1,124 @@
+module MultiTenant
+  module Impl
+    #
+    # An implementation where Tenant.current is set to the current tenant, or nil. 
+    #
+    class SingleCurrent
+      attr_reader :tenant_class
+
+      def initialize(tenant_class)
+        @tenant_class = tenant_class
+      end
+
+      def acts_as_tenant_class_methods
+        ActsAsTenantClassMethods
+      end
+
+      def belongs_to_tenant_instance_methods
+        BelongsToTenantInstanceMethods
+      end
+
+      def belongs_to_tenant_default_scope(model)
+        -> {
+          current = model.tenant_class.current
+          current ? model.where({model.tenant_foreign_key => current.send(model.tenant_primary_key)}) : model.where('1=1')
+        }
+      end
+
+      def belongs_to_tenant_through_default_scope(model, ref)
+        -> {
+          tenant = model.delegate_class.tenant_class.current
+          next model.where('1=1') if tenant.nil?
+
+          # Using straight sql so we can JOIN against two columns. Otherwise one must go into "WHERE", and Arel would apply it to UPDATEs and DELETEs.
+          quoted_tenant_id = model.connection.quote tenant.send model.delegate_class.tenant_primary_key
+          model.joins("INNER JOIN #{ref.klass.table_name} ON #{ref.klass.table_name}.#{ref.foreign_key}=#{model.table_name}.#{ref.association_primary_key} AND #{ref.klass.table_name}.#{ref.klass.tenant_foreign_key}=#{quoted_tenant_id}").
+            readonly(false) # using "joins" makes records readonly, which we don't want
+        }
+      end
+
+      def proxies_to_tenant_class_methods(ref)
+        case [ref.macro, ref.inverse_of.macro]
+        when [:has_many, :belongs_to], [:has_one, :belongs_to], [:belongs_to, :has_one]
+          ProxiesToTenantSingularInverseAssociation
+        else
+          raise MultiTenant::Impl::NotImplemented, "`proxies_to_tenant` does not currently support `#{ref.macro}` associations with `#{ref.inverse_of.macro} inverses."
+          ProxiesToTenantPluralInverseAssociation
+        end
+      end
+
+      def matching_globals(record_or_identifier, globals)
+        id = record_or_identifier.is_a?(tenant_class) ? record_or_identifier.send(tenant_class.tenant_identifier) : record_or_identifier
+        globals.has_key?(id) ? [globals[id]] : []
+      end
+
+      #
+      # Class methods given to the tenant model.
+      #
+      module ActsAsTenantClassMethods
+        def current?
+          !current.nil?
+        end
+
+        def resolve_tenant(record_or_identifier)
+          if record_or_identifier.is_a? self
+            record_or_identifier
+          elsif record_or_identifier
+            where({tenant_identifier => record_or_identifier}).first
+          else
+            nil
+          end
+        end
+      end
+
+      #
+      # Instance methods given to tenant-owned models.
+      #
+      module BelongsToTenantInstanceMethods
+        def self.included(model)
+          model.class_eval do
+            before_validation :assign_to_tenant
+          end
+        end
+
+        private
+
+        #
+        # Assign this model to the current tenant (if any)
+        #
+        def assign_to_tenant
+          if self.class.tenant_class.current
+            current_tenant_id = self.class.tenant_class.current.send(self.class.tenant_primary_key)
+            send "#{self.class.tenant_foreign_key}=", current_tenant_id
+          end
+        end
+      end
+
+      #
+      # Class methods for tenant proxies that have a singular inverse association (i.e. belongs_to or has_one).
+      #
+      module ProxiesToTenantSingularInverseAssociation
+        # Returns the current record of the proxy model
+        def current
+          if (tenant = proxied_tenant_class.current)
+            tenant.send proxied_tenant_inverse_assoc
+          end
+        end
+      end
+
+      #
+      # Class methods for tenant proxies that have a plural inverse association (i.e. has_many).
+      # NOTE These are just some thoughts on *maybe* how to support this if we ever need it.
+      #
+      module ProxiesToTenantPluralInverseAssociation
+        # Returns the current record of the proxy model
+        def current
+          raise MultiTenant::Impl::NotImplemented, "needs confirmed"
+          if (tenant = proxied_tenant_class.current)
+            tenant.send(proxied_tenant_inverse_assoc).instance_eval(&proxied_tenant_inverse_scope).first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multi_tenant/middleware.rb

@@ -47,7 +47,8 @@ module MultiTenant
 
     # Default Proc for the not_found option
     DEFAULT_NOT_FOUND = ->(x) {
-      [404, {'Content-Type' => 'text/html', 'Content-Length' => (33 + x.to_s.size).to_s}, ['<h1>\'%s\' is not a valid tenant</h1>' % x.to_s]]
+      body = "<h1>Invalid tenant: #{Array(x).map(&:to_s).join ', '}</h1>"
+      [404, {'Content-Type' => 'text/html', 'Content-Length' => body.size.to_s}, [body]]
     }
 
     #
@@ -73,15 +74,18 @@ module MultiTenant
     # Rack request call
     def call(env)
       tenant_class.current = nil
+      impl = tenant_class.multi_tenant_impl
+
       request = Rack::Request.new env
       tenant_identifier = identifier.(request)
 
-      if (allowed_paths = globals[tenant_identifier])
-        allowed = path_matches?(request, allowed_paths)
+      if (matching_globals = impl.matching_globals(tenant_identifier, globals)).any?
+        allowed = matching_globals.any? { |allowed_paths|
+          path_matches?(request, allowed_paths)
+        }
         return allowed ? @app.call(env) : not_found.(tenant_identifier)
 
-      elsif (tenant = tenant_class.where({tenant_class.tenant_identifier => tenant_identifier}).first)
-        tenant_class.current = tenant
+      elsif (tenant_class.current = tenant_identifier) and tenant_class.current?
         return @app.call env
 
       else

data/lib/multi_tenant/proxies_to_tenant.rb

@@ -52,17 +52,14 @@ module MultiTenant
       raise "`proxies_to_tenant :#{association_name}`: #{reflection.klass.name} must use `acts_as_tenant`" if !reflection.klass.acts_as_tenant?
       raise "`proxies_to_tenant :#{association_name}`: the `:#{association_name}` association must use the `:inverse_of` option." if reflection.inverse_of.nil?
 
-      case [reflection.macro, reflection.inverse_of.macro]
-      when [:has_many, :belongs_to], [:has_one, :belongs_to], [:belongs_to, :has_one]
-        self.extend SingularInverseAssociation
-      else
-        raise "`proxies_to_tenant` does not currently support `#{reflection.macro}` associations with `#{reflection.inverse_of.macro} inverses."
-      end
-
       cattr_accessor :proxied_tenant_class, :proxied_tenant_inverse_assoc, :proxied_tenant_inverse_scope
       self.proxied_tenant_class = reflection.klass
       self.proxied_tenant_inverse_assoc = reflection.inverse_of.name
       self.proxied_tenant_inverse_scope = scope
+
+      impl = self.proxied_tenant_class.multi_tenant_impl
+      self.extend impl.proxies_to_tenant_class_methods(reflection)
+      self.extend ClassMethods
     end
 
     #
@@ -74,25 +71,12 @@ module MultiTenant
       respond_to? :proxied_tenant_class
     end
 
-    private
-
-    # Class methods for tenant proxies that have a singular inverse association (i.e. belongs_to or has_one).
-    module SingularInverseAssociation
-      # Returns the "current" record of the proxy model
-      def current
-        if (tenant = proxied_tenant_class.current)
-          tenant.send proxied_tenant_inverse_assoc
-        end
-      end
-    end
-
-    # NOTE just some thoughts on *maybe* how to support this if we ever need it.
-    module PluralInverseAssociation
-      # Returns the "current" record of the proxy model
-      def current
-        if (tenant = proxied_tenant_class.current)
-          tenant.send(proxied_tenant_inverse_assoc).instance_eval(&proxied_tenant_inverse_scope).first
-        end
+    #
+    # Class methods given to proxies.
+    #
+    module ClassMethods
+      def multi_tenant_impl
+        proxied_tenant_class.multi_tenant_impl
       end
     end
   end

data/lib/multi_tenant/version.rb

@@ -1,4 +1,4 @@
 module MultiTenant
   # Gem version
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.2.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_multi_tenant
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jordan Hollinger
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-07 00:00:00.000000000 Z
+date: 2018-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -58,6 +58,8 @@ files:
 - lib/multi_tenant/acts_as_tenant.rb
 - lib/multi_tenant/belongs_to_tenant.rb
 - lib/multi_tenant/belongs_to_tenant_through.rb
+- lib/multi_tenant/impl/multiple_current.rb
+- lib/multi_tenant/impl/single_current.rb
 - lib/multi_tenant/middleware.rb
 - lib/multi_tenant/proxies_to_tenant.rb
 - lib/multi_tenant/version.rb