mongoid-multitenancy-forked 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca01ab6c53dd07de80b689a0364f4fc57ddb975fbce3951251a4540a8df890db
+  data.tar.gz: 8e86b6a4acfa0d6b036a7af7fbeaef21a386a1b543bbfa7920df70d64fb592e8
+SHA512:
+  metadata.gz: 578304563260d2096c4d59883eb1174a2bbeb7a5c46d48fa13b3a0ced7e7d94b6cbfe442f1131cd838b38b2d9c7c744a693f0ebcf6ad3b909fb1512014a50cf1
+  data.tar.gz: abaa3606883c0c64677e6bec188c40afdfacb5270dafdf7638fe5dc5575aefc3e7cbbd4af106b88cf4b9b995ac50854039008526c3c2cc34b67461e060e5e2be

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+Gemfile*.lock
+
+.idea

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--order random

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - 2.3.0
+  - 2.4.1
+gemfile:
+  - gemfiles/Gemfile.mongoid-6
+  - gemfiles/Gemfile.mongoid-7
+  - Gemfile
+services:
+  - mongodb
+sudo: false

data/CHANGELOG.md

@@ -0,0 +1,56 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [2.0.3] - 2020-06-25
+### Fixed
+
+* Full Support of mongoid 7
+
+## [2.0.2] - 2018-08-23
+### Added
+
+* Support of mongoid 7
+
+## [2.0.1] - 2017-12-14
+### Changed
+
+* Add ensure block in method with_tenant
+
+## [2.0] - 2017-07-21
+### New Features
+
+* Add support for mongoid 6
+* Remove support for mongoid 4 & 5
+
+## 1.2
+
+### New Features
+
+* Add *exclude_shared* option for the TenantUniquenessValidator
+
+## 1.1
+
+### New Features
+
+* Add scopes *shared* and *unshared* (1b5c420)
+
+### Fixes
+
+* When a tenant is optional, do not override the tenant during persisted document initialization (81a9b45)
+
+## 1.0.0
+
+### New Features
+
+* Add support for mongoid 5
+
+### Major Changes (Backwards Incompatible)
+
+* Drops support for mongoid 3
+
+* An optional tenant is now automatically set if a current tenant is defined.
+
+* A unique constraint with an optional tenant now uses the client scoping. An item cannot be shared if another client item has the same value.

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+
+group :test do
+  gem 'database_cleaner-mongoid'
+  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
+
+# Specify your gem's dependencies in mongoid-multitenancy.gemspec
+gemspec

data/LICENSE.TXT

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Perfect Memory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,284 @@
+# mongoid-multitenancy [![Build Status](https://api.travis-ci.org/PerfectMemory/mongoid-multitenancy.png?branch=master)](https://travis-ci.org/PerfectMemory/mongoid-multitenancy) [![Coverage Status](https://coveralls.io/repos/github/PerfectMemory/mongoid-multitenancy/badge.svg?branch=master)](https://coveralls.io/github/PerfectMemory/mongoid-multitenancy?branch=master) [![Code Climate](https://codeclimate.com/github/PerfectMemory/mongoid-multitenancy.png)](https://codeclimate.com/github/PerfectMemory/mongoid-multitenancy)
+
+mongoid-multitenancy adds the ability to scope [Mongoid](https://github.com/mongoid/mongoid) models to a tenant in a **shared database strategy**. Tenants are represented by a tenant model, such as `Client`. mongoid-multitenancy will help you set the current tenant on each request and ensures that all 'tenant models' are always properly scoped to the current tenant: when viewing, searching and creating.
+
+It is directly inspired by the [acts_as_tenant gem](https://github.com/ErwinM/acts_as_tenant) for Active Record.
+
+In addition, mongoid-multitenancy:
+
+* allows you to set the current tenant
+* allows shared items between the tenants
+* allows you to define an immutable tenant field once it is persisted
+* is thread safe
+* redefines some mongoid functions like `index`, `validates_with` and `delete_all` to take in account the multitenancy.
+
+Compatibility
+===============
+
+mongoid-multitenancy 2.0 is compatible with mongoid 6/7. For mongoid 4/5 compatiblity, use mongoid-multitenancy 1.2.
+
+Installation
+===============
+
+Add this line to your application's Gemfile:
+
+    gem 'mongoid-multitenancy', '~> 2.0'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid-multitenancy
+
+Usage
+===============
+
+There are two steps to add multi-tenancy to your app with mongoid-multitenancy:
+
+1. setting the current tenant and
+2. scoping your models.
+
+Setting the current tenant
+--------------------------
+There are two ways to set the current tenant: (1) by setting the current tenant manually, or (2) by setting the current tenant for a block.
+
+**Setting the current tenant in a controller, manually**
+
+```ruby
+Mongoid::Multitenancy.current_tenant = client_instance
+```
+
+Setting the current_tenant yourself requires you to use a before_filter to set the Mongoid::Multitenancy.current_tenant variable.
+
+**Setting the current tenant for a block**
+
+```ruby
+Mongoid::Multitenancy.with_tenant(client_instance) do
+  # Current tenant is set for all code in this block
+end
+```
+
+This approach is useful when running background processes for a specified tenant. For example, by putting this in your worker's run method,
+any code in this block will be scoped to the current tenant. All methods that set the current tenant are thread safe.
+
+**Note:** If the current tenant is not set by one of these methods, mongoid-multitenancy will apply a global scope to your models, not related to any tenant. So make sure you use one of the two methods to tell mongoid-multitenancy about the current tenant.
+
+Scoping your models
+-------------------
+```ruby
+class Client
+  include Mongoid::Document
+
+  field :name, :type => String
+  validates_uniqueness_of :name
+end
+
+class Article
+  include Mongoid::Document
+  include Mongoid::Multitenancy::Document
+
+  tenant(:tenant)
+
+  field :title, :type => String
+end
+```
+
+Adding `tenant` to your model declaration will scope that model to the current tenant **BUT ONLY if a current tenant has been set**.
+The association passed to the `tenant` function must be valid.
+
+`tenant` accepts several options:
+
+| Option  | Default | Description |
+| ------------- | ------------- | ------------- |
+| :optional  | false  | set to true when the tenant is optional |
+| :immutable  | true  | set to true when the tenant field is immutable |
+| :full_indexes  | true  | set to true to add the tenant field automatically to all the indexes |
+| :index  | false  | set to true to define an index for the tenant field |
+| :scopes  | true  | set to true to define scopes :shared and :unshared |
+| :class_name, etc. |   | all the other options will be passed to the mongoid relation (belongs_to) |
+
+Some examples to illustrate this behavior:
+
+```ruby
+ # This manually sets the current tenant for testing purposes. In your app this is handled by the gem.
+Mongoid::Multitenancy.current_tenant = Client.find_by(:name => 'Perfect Memory') # => <#Client _id:50ca04b86c82bfc125000025, :name: "Perfect Memory">
+
+ # All searches are scoped by the tenant, the following searches will only return objects belonging to the current client.
+Article.all # => all articles where tenant_id => 50ca04b86c82bfc125000025
+
+ # New objects are scoped to the current tenant
+article = Article.new(:title => 'New blog')
+article.save # => <#Article _id: 50ca04b86c82bfc125000044, title: 'New blog', tenant_id: 50ca04b86c82bfc125000025>
+
+ # It can make the tenant field immutable once it is persisted to avoid inconsistency
+article.persisted? # => true
+article.tenant = another_client
+article.valid? # => false
+```
+
+**Optional tenant**
+
+When setting an optional tenant, for example to allow shared instances between all the tenants, the default scope will return both the tenant and the free-tenant items. That means that using `Article.delete_all` or `Article.destroy_all` will **remove the shared items too**.
+
+Note: if a current tenant is set and you want to mark the item shared, you must explicitly set the tenant relation to nil after the initialization.
+
+```ruby
+class Article
+  include Mongoid::Document
+  include Mongoid::Multitenancy::Document
+
+  tenant(:tenant, optional: true)
+
+  field :title, :type => String
+end
+
+Mongoid::Multitenancy.with_tenant(client_instance) do
+  Article.all # => all articles where tenant_id.in [50ca04b86c82bfc125000025, nil]
+  article = Article.new(:title => 'New article')
+  article.save # => <#Article _id: 50ca04b86c82bfc125000044, title: 'New blog', tenant_id: 50ca04b86c82bfc125000025>
+
+  # tenant needs to be set manually to nil
+  article = Article.new(:title => 'New article', :tenant => nil)
+  article.save # => <#Article _id: 50ca04b86c82bfc125000044, title: 'New blog', tenant_id: 50ca04b86c82bfc125000025>
+  article.tenant = nil
+  article.save => <#Article _id: 50ca04b86c82bfc125000044, title: 'New blog', tenant_id: nil>
+end
+```
+
+Rails
+-------------------
+
+If you are using Rails, you may want to set the current tenant at each request.
+
+**Manually set the current tenant in ApplicationController using the host request**
+
+```ruby
+class ApplicationController < ActionController::Base
+  before_filter :set_current_client
+
+  def set_current_client
+    current_client = Client.find_by_host(request.host)
+    Mongoid::Multitenancy.current_tenant = current_client
+  end
+end
+```
+
+Setting the current_tenant yourself requires you to use a before_filter to set the Mongoid::Multitenancy.current_tenant variable.
+
+Mongoid Uniqueness validators
+-------------------
+
+mongoid-multitenancy brings a TenantUniqueness validator that will, depending on the tenant options, check that your uniqueness
+constraints are respected:
+
+* When used with a *mandatory* tenant, the uniqueness constraint is scoped to the current client.
+
+In the following case, 2 articles can have the same slug if they belongs to 2 different clients.
+
+```ruby
+class Article
+  include Mongoid::Document
+  include Mongoid::Multitenancy::Document
+
+  tenant :tenant
+
+  field :slug
+
+  validates_tenant_uniqueness_of :slug
+end
+```
+
+* When used with an *optional* tenant, the uniqueness constraint by default is not scoped if the item is shared, but is
+  scoped to the client new item otherwise. Note that by default in that case a private item cannot have a value if a shared item
+  already uses it. You can change that behaviour by setting the option `exclude_shared` to `true`.
+
+In the following case, 2 private articles can have the same slug if they belongs to 2 different clients. But if a shared
+article has the slug "slugA", no client will be able to use that slug again, like a standard `validates_uniqueness_of` does.
+
+```ruby
+class Article
+  include Mongoid::Document
+  include Mongoid::Multitenancy::Document
+
+  tenant :tenant, optional: true
+
+  field :slug
+
+  validates_tenant_uniqueness_of :slug
+end
+```
+
+In the following case, 2 private articles can have the same slug if they belongs to 2 different clients even if a shared
+article already uses that same slug, like a `validates_uniqueness_of scope: :tenant` does.
+
+```ruby
+class Article
+  include Mongoid::Document
+  include Mongoid::Multitenancy::Document
+
+  tenant :tenant, optional: true
+
+  field :slug
+
+  validates_tenant_uniqueness_of :slug, exclude_shared: true
+end
+```
+
+Mongoid indexes
+-------------------
+
+mongoid-multitenancy automatically adds the tenant foreign key in all your mongoid indexes to avoid to redefine all your validators. If you prefer to define the indexes manually, you can use the option `full_indexes: false` on the tenant or `full_index: true/false` on the indexes.
+
+To create a single index on the tenant field, you can use the option `index: true` like any `belongs_to` declaration (false by default)
+
+On the example below, only one index will be created:
+
+* { 'tenant_id' => 1, 'title' => 1 }
+
+```ruby
+class Article
+  include Mongoid::Document
+  include Mongoid::Multitenancy::Document
+
+  tenant :tenant, full_indexes: true
+
+  field :title
+
+  index({ :title => 1 })
+end
+```
+
+On the example below, 3 indexes will be created:
+
+* { 'tenant_id' => 1 }
+* { 'tenant_id' => 1, 'title' => 1 }
+* { 'name' => 1 }
+
+```ruby
+class Article
+  include Mongoid::Document
+  include Mongoid::Multitenancy::Document
+
+  tenant :tenant, index: true
+
+  field :title
+  field :name
+
+  index({ :title => 1 })
+  index({ :name => 1 }, { full_index: false })
+end
+```
+
+Author & Credits
+----------------
+mongoid-multitenancy is written by [Aymeric Brisse](https://github.com/abrisse/), from [Perfect Memory](http://www.perfect-memory.com).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+YARD::Rake::YardocTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/gemfiles/Gemfile.mongoid-6

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gem 'mongoid', '~> 6.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/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/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)
+          super_options = (options || {}).dup
+          full_index = super_options.delete(:full_index)
+          if full_index.nil? ? tenant_options[:full_indexes] : full_index
+            spec = { tenant_field => 1 }.merge(spec)
+          end
+
+          super(spec, super_options)
+        end
+
+        # Redefine 'delete_all' to take in account the default scope
+        def delete_all(conditions = {})
+          scoped.where(conditions).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