mongoid-multitenancy-2 2.0.3

data/gemfiles/Gemfile.mongoid-7

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gem 'mongoid', '~> 7.0'
+
+gem 'rake'
+
+group :test do
+  gem 'database_cleaner'
+  gem 'coveralls', require: false
+  gem 'rspec', '~> 3.1'
+  gem 'yard'
+  gem 'mongoid-rspec', git: 'https://github.com/mongoid-rspec/mongoid-rspec.git'
+  gem 'rubocop', require: false
+end

data/lib/mongoid-multitenancy.rb

@@ -0,0 +1 @@
+require 'mongoid/multitenancy'

data/lib/mongoid/multitenancy.rb

@@ -0,0 +1,34 @@
+require 'mongoid'
+require 'mongoid/multitenancy/document'
+require 'mongoid/multitenancy/version'
+require 'mongoid/multitenancy/validators/tenancy'
+require 'mongoid/multitenancy/validators/tenant_uniqueness'
+
+module Mongoid
+  module Multitenancy
+    class << self
+      # Set the current tenant. Make it Thread aware
+      def current_tenant=(tenant)
+        Thread.current[:current_tenant] = tenant
+      end
+
+      # Returns the current tenant
+      def current_tenant
+        Thread.current[:current_tenant]
+      end
+
+      # Affects a tenant temporary for a block execution
+      def with_tenant(tenant, &block)
+        raise ArgumentError, 'block required' if block.nil?
+
+        begin
+          old_tenant = current_tenant
+          self.current_tenant = tenant
+          yield
+        ensure
+          self.current_tenant = old_tenant
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/multitenancy/document.rb

@@ -0,0 +1,176 @@
+module Mongoid
+  module Multitenancy
+    module Document
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        attr_accessor :tenant_field, :tenant_options
+
+        # List of authorized options
+        MULTITENANCY_OPTIONS = [:optional, :immutable, :full_indexes, :index, :scopes].freeze
+
+        # Defines the tenant field for the document.
+        #
+        # @example Define a tenant.
+        #   tenant :client, optional: false, immutable: true, full_indexes: true
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        #   All the belongs_to options are allowed plus the following ones:
+        #
+        # @option options [ Boolean ] :full_indexes If true the tenant field
+        #   will be added for each index.
+        # @option options [ Boolean ] :immutable If true changing the tenant
+        #   wil raise an Exception.
+        # @option options [ Boolean ] :optional If true allow the document
+        #   to be shared among all the tenants.
+        # @option options [ Boolean ] :index If true build an index for
+        #   the tenant field itself.
+        # @option options [ Boolean ] :scopes If true create scopes :shared
+        #   and :unshared.
+        # @return [ Field ] The generated field
+        def tenant(association = :account, options = {})
+          options = { full_indexes: true, immutable: true, scopes: true }.merge!(options)
+          assoc_options, multitenant_options = build_options(options)
+
+          # Setup the association between the class and the tenant class
+          belongs_to association, assoc_options
+
+          # Get the tenant model and its foreign key
+          self.tenant_field = reflect_on_association(association).foreign_key.to_sym
+          self.tenant_options = multitenant_options
+
+          # Validates the tenant field
+          validates_tenancy_of tenant_field, multitenant_options
+
+          define_scopes if multitenant_options[:scopes]
+          define_initializer association
+          define_inherited association, options
+          define_index if multitenant_options[:index]
+        end
+
+        # Validates whether or not a field is unique against the documents in the
+        # database.
+        #
+        # @example
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     include Mongoid::Multitenancy::Document
+        #     field :title
+        #
+        #     validates_tenant_uniqueness_of :title
+        #   end
+        #
+        # @param [ Array ] *args The arguments to pass to the validator.
+        def validates_tenant_uniqueness_of(*args)
+          validates_with(TenantUniquenessValidator, _merge_attributes(args))
+        end
+
+        # Validates whether or not a tenant field is correct.
+        #
+        # @example Define the tenant validator
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     include Mongoid::Multitenancy::Document
+        #     field :title
+        #     tenant :client
+        #
+        #     validates_tenant_of :client
+        #   end
+        #
+        # @param [ Array ] *args The arguments to pass to the validator.
+        def validates_tenancy_of(*args)
+          validates_with(TenancyValidator, _merge_attributes(args))
+        end
+
+        # Redefine 'index' to include the tenant field in first position
+        def index(spec, options = nil)
+          if tenant_options[:full_indexes]
+            spec = { tenant_field => 1 }.merge(spec)
+          end
+
+          super(spec, options)
+        end
+
+        # Redefine 'delete_all' to take in account the default scope
+        def delete_all(conditions = nil)
+          scope = scoped
+          scope = scopewhere(conditions) if conditions
+          scope.delete
+        end
+
+        private
+
+        # @private
+        def build_options(options)
+          assoc_options = {}
+          multitenant_options = {}
+
+          options.each do |k, v|
+            if MULTITENANCY_OPTIONS.include?(k)
+              multitenant_options[k] = v
+              assoc_options[k] = v if k == :optional
+            else
+              assoc_options[k] = v
+            end
+          end
+
+          [assoc_options, multitenant_options]
+        end
+
+        # @private
+        #
+        # Define the after_initialize
+        def define_initializer(association)
+          # Apply the default value when the default scope is complex (optional tenant)
+          after_initialize lambda {
+            if Multitenancy.current_tenant && new_record?
+              send "#{association}=".to_sym, Multitenancy.current_tenant
+            end
+          }
+        end
+
+        # @private
+        #
+        # Define the inherited method
+        def define_inherited(association, options)
+          define_singleton_method(:inherited) do |child|
+            child.tenant association, options.merge(scopes: false)
+            super(child)
+          end
+        end
+
+        # @private
+        #
+        # Define the scopes
+        def define_scopes
+          # Set the default_scope to scope to current tenant
+          default_scope lambda {
+            if Multitenancy.current_tenant
+              tenant_id = Multitenancy.current_tenant.id
+              if tenant_options[:optional]
+                where(tenant_field.in => [tenant_id, nil])
+              else
+                where(tenant_field => tenant_id)
+              end
+            else
+              all
+            end
+          }
+
+          scope :shared, -> { where(tenant_field => nil) }
+          scope :unshared, -> { where(tenant_field => Multitenancy.current_tenant.id) }
+        end
+
+        # @private
+        #
+        # Create the index
+        def define_index
+          index({ tenant_field => 1 }, background: true)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/multitenancy/validators/tenancy.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  module Multitenancy
+    # Validates whether or not a tenant field is correct.
+    #
+    # @example Define the tenant validator
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     include Mongoid::Multitenancy::Document
+    #     field :title
+    #     tenant :client
+    #
+    #     validates_tenancy_of :client
+    #   end
+    class TenancyValidator < ActiveModel::EachValidator
+      def validate_each(object, attribute, value)
+        # Immutable Check
+        if options[:immutable]
+          if object.send(:attribute_changed?, attribute) && object.send(:attribute_was, attribute)
+            object.errors.add(attribute, 'is immutable and cannot be updated')
+          end
+        end
+
+        # Ownership check
+        if value && Mongoid::Multitenancy.current_tenant && value != Mongoid::Multitenancy.current_tenant.id
+          object.errors.add(attribute, 'not authorized')
+        end
+
+        # Optional Check
+        if !options[:optional] && value.nil?
+          object.errors.add(attribute, 'is mandatory')
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/multitenancy/validators/tenant_uniqueness.rb

@@ -0,0 +1,67 @@
+module Mongoid
+  module Multitenancy
+    # Validates whether or not a field is unique against the documents in the
+    # database.
+    #
+    # @example Define the tenant uniqueness validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     include Mongoid::Multitenancy::Document
+    #     field :title
+    #     tenant :client
+    #
+    #     validates_tenant_uniqueness_of :title
+    #   end
+    #
+    # It is also possible to limit the uniqueness constraint to a set of
+    # records matching certain conditions:
+    #   class Person
+    #     include Mongoid::Document
+    #     include Mongoid::Multitenancy::Document
+    #     field :title
+    #     field :active, type: Boolean
+    #     tenant :client
+    #
+    #     validates_tenant_uniqueness_of :title, conditions: -> {where(active: true)}
+    #   end
+    class TenantUniquenessValidator < Mongoid::Validatable::UniquenessValidator
+      # Validate a tenant root document.
+      def validate_root(document, attribute, value)
+        klass = document.class
+
+        while klass.superclass.respond_to?(:validators) && klass.superclass.validators.include?(self)
+          klass = klass.superclass
+        end
+        criteria = create_criteria(klass, document, attribute, value)
+
+        # <<Add the tenant Criteria>>
+        criteria = with_tenant_criterion(criteria, klass, document)
+        criteria = criteria.merge(options[:conditions].call) if options[:conditions]
+
+        if criteria.read(mode: :primary).exists?
+          add_error(document, attribute, value)
+        end
+      end
+
+      # Add the scope criteria for a tenant model criteria.
+      #
+      # @api private
+      def with_tenant_criterion(criteria, base, document)
+        item = base.tenant_field.to_sym
+        name = document.database_field_name(item)
+        tenant_value = document.attributes[name]
+
+        if document.class.tenant_options[:optional] && !options[:exclude_shared]
+          if tenant_value
+            criteria = criteria.where(:"#{item}".in => [tenant_value, nil])
+          end
+        else
+          criteria = criteria.where(item => tenant_value)
+        end
+
+        criteria
+      end
+    end
+  end
+end

data/lib/mongoid/multitenancy/version.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  module Multitenancy
+    # Version
+    VERSION = '2.0.3'.freeze
+  end
+end

data/mongoid-multitenancy.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mongoid/multitenancy/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Botond Orban', 'Aymeric Brisse']
+  gem.email         = ['botondorban@gmail.com']
+  gem.description   = 'MultiTenancy with Mongoid'
+  gem.summary       = 'Support of a multi-tenant database with Mongoid'
+  gem.homepage      = 'https://github.com/orbanbotond/mongoid-multitenancy'
+  gem.license       = 'MIT'
+  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'mongoid-multitenancy-2'
+  gem.require_paths = ['lib']
+  gem.version       = Mongoid::Multitenancy::VERSION
+
+  gem.add_dependency('mongoid', '~> 7')
+end

data/spec/immutable_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Immutable do
+  let(:client) do
+    Account.create!(name: 'client')
+  end
+
+  let(:another_client) do
+    Account.create!(name: 'another client')
+  end
+
+  let(:item) do
+    Immutable.new(title: 'title X', slug: 'page-x')
+  end
+
+  it_behaves_like 'a tenantable model'
+
+  describe '#valid?' do
+    before do
+      Mongoid::Multitenancy.current_tenant = client
+    end
+
+    context 'when the tenant has not changed' do
+      before do
+        item.save!
+      end
+
+      it 'is valid' do
+        item.title = 'title X (2)'
+        expect(item).to be_valid
+      end
+    end
+
+    context 'when the tenant has changed' do
+      before do
+        item.save!
+        Mongoid::Multitenancy.current_tenant = another_client
+      end
+
+      it 'is not valid' do
+        item.tenant = another_client
+        expect(item).not_to be_valid
+      end
+    end
+  end
+end

data/spec/indexable_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'tenant' do
+  let(:client) do
+    Account.create!(name: 'client')
+  end
+
+  before do
+    Mongoid::Multitenancy.current_tenant = client
+  end
+
+  context 'without index: true' do
+    it 'does not create an index' do
+      expect(Immutable).not_to have_index_for(tenant_id: 1)
+    end
+  end
+
+  context 'with index: true' do
+    it 'creates an index' do
+      expect(Indexable).to have_index_for(tenant_id: 1)
+    end
+  end
+
+  context 'with full_indexes: true' do
+    it 'add the tenant field on each index' do
+      expect(Immutable).to have_index_for(tenant_id: 1, title: 1)
+    end
+  end
+
+  context 'with full_indexes: false' do
+    it 'does not add the tenant field on each index' do
+      expect(Indexable).not_to have_index_for(tenant_id: 1, title: 1)
+    end
+  end
+end