sanger-jsonapi-resources 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9bc1314c078c61f44653dd5aa8b24e271853bf8be84b5d41eced75795b56ad2
-  data.tar.gz: deee25658162d4971d977153214a2373db3599708f4c69d94d8662a5f90cdcfd
+  metadata.gz: 650cd436866c1e2bd95395039f642430ac9d0f1742e16b6229e4ff6c02749194
+  data.tar.gz: 8617ac86f123744a591f9d669c91e09210ba86840448037d8e087be15a755296
 SHA512:
-  metadata.gz: 24e0ea2c4aa90ceab8dd3b5a5f38a127566a1e8bc7b58d83b1e5f22a488df0f4bc1eeef8685a0fd60ff35efdbed68ca75be6d9b662f6a0da95fa150da783dadd
-  data.tar.gz: baee2a71eff19ef87efc2e6223ae93b5d47e346859cf777bf197f377eefe5dda886627c2bfa65a90294dda427b8f3724580ed85e887a3ff0d19435c5b9a0aca0
+  metadata.gz: 9287ea3df53d25721525c1e98b49bcdca8d7c936ec7674b649324a41dcde991e9a2c80cb464d273150710ab9fcf3a758c890788136d4f667552f3e5f0951c655
+  data.tar.gz: d85e68eb490870d9adafa8af7d63d6b7413aeb2c03be43efb510a9d4171b13dab763faff29fcf1610e6ea4ff7dfa4ef72b0530a678ebd4421c56489bdf12a682

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Larry Gebhardt
+Copyright (c) 2014-2021 Cerebris Corporation
 
 MIT License
 

data/README.md

@@ -1,4 +1,4 @@
-# JSONAPI::Resources [![Gem Version](https://badge.fury.io/rb/jsonapi-resources.svg)](https://badge.fury.io/rb/jsonapi-resources) [![Build Status](https://secure.travis-ci.org/cerebris/jsonapi-resources.svg?branch=beta)](http://travis-ci.org/cerebris/jsonapi-resources) [![Code Climate](https://codeclimate.com/github/cerebris/jsonapi-resources/badges/gpa.svg)](https://codeclimate.com/github/cerebris/jsonapi-resources)
+# JSONAPI::Resources [![Gem Version](https://badge.fury.io/rb/jsonapi-resources.svg)](https://badge.fury.io/rb/jsonapi-resources) [![Build Status](https://secure.travis-ci.org/cerebris/jsonapi-resources.svg?branch=master)](http://travis-ci.org/cerebris/jsonapi-resources) [![Code Climate](https://codeclimate.com/github/cerebris/jsonapi-resources/badges/gpa.svg)](https://codeclimate.com/github/cerebris/jsonapi-resources)
 
 [![Join the chat at https://gitter.im/cerebris/jsonapi-resources](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/cerebris/jsonapi-resources?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
@@ -8,12 +8,12 @@
 Like JSON:API itself, JR's design is focused on the resources served by an API. JR needs little more than a definition
 of your resources, including their attributes and relationships, to make your server compliant with JSON API.
 
-JR is designed to work with Rails 4.2+, and provides custom routes, controllers, and serializers. JR's resources may be
+JR is designed to work with Rails 5.1+, and provides custom routes, controllers, and serializers. JR's resources may be
 backed by ActiveRecord models or by custom objects.
 
 ## Documentation
 
-Full documentation can be found at [http://jsonapi-resources.com](http://jsonapi-resources.com), including the [v0.9 beta Guide](http://jsonapi-resources.com/v0.9/guide/) specific to this version. 
+Full documentation can be found at [http://jsonapi-resources.com](http://jsonapi-resources.com), including the [v0.10 alpha Guide](http://jsonapi-resources.com/v0.10/guide/) specific to this version. 
 
 ## Demo App
 
@@ -28,26 +28,49 @@ which *should* be compatible with JSON:API compliant server implementations such
 
 Add JR to your application's `Gemfile`:
 
-    gem 'sanger-jsonapi-resources'
+``` 
+gem 'jsonapi-resources'
+```
 
 And then execute:
 
-    $ bundle
+```bash 
+bundle
+```
 
 Or install it yourself as:
 
-    $ gem install sanger-jsonapi-resources
+```bash 
+gem install jsonapi-resources
+```
 
-**For further usage see the [v0.9 beta Guide](http://jsonapi-resources.com/v0.9/guide/)**
+**For further usage see the [v0.10 alpha Guide](http://jsonapi-resources.com/v0.10/guide/)**
 
 ## Contributing
 
+1. Submit an issue describing any new features you wish it add or the bug you intend to fix
 1. Fork it ( http://github.com/cerebris/jsonapi-resources/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. Run the full test suite (`rake test`)
+1. Fix any failing tests
+1. Commit your changes (`git commit -am 'Add some feature'`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Create a new Pull Request
+
+## Did you find a bug?
+
+* **Ensure the bug was not already reported** by searching on GitHub under [Issues](https://github.com/cerebris/jsonapi-resources/issues).
+
+* If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/cerebris/jsonapi-resources/issues/new). 
+Be sure to include a **title and clear description**, as much relevant information as possible, 
+and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring.
+
+* If possible, use the relevant bug report templates to create the issue. 
+Simply copy the content of the appropriate template into a .rb file, make the necessary changes to demonstrate the issue, 
+and **paste the content into the issue description or attach as a file**:
+  * [**Rails 5** issues](https://github.com/cerebris/jsonapi-resources/blob/master/lib/bug_report_templates/rails_5_master.rb)
+
 
 ## License
 
-Copyright 2014-2016 Cerebris Corporation. MIT License (see LICENSE for details).
+Copyright 2014-2021 Cerebris Corporation. MIT License (see LICENSE for details).

data/lib/bug_report_templates/rails_5_latest.rb

@@ -0,0 +1,125 @@
+begin
+  require 'bundler/inline'
+rescue LoadError => e
+  STDERR.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
+  raise e
+end
+
+gemfile(true) do
+  source 'https://rubygems.org'
+
+  gem 'rails', require: false
+  gem 'sqlite3', platform: :mri
+
+  gem 'activerecord-jdbcsqlite3-adapter',
+      git: 'https://github.com/jruby/activerecord-jdbc-adapter',
+      branch: 'rails-5',
+      platform: :jruby
+
+  gem 'jsonapi-resources', require: false
+end
+
+# prepare active_record database
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Schema.define do
+  # Add your schema here
+  create_table :your_models, force: true do |t|
+    t.string :name
+  end
+end
+
+# create models
+class YourModel < ActiveRecord::Base
+end
+
+# prepare rails app
+require 'action_controller/railtie'
+# require 'action_view/railtie'
+require 'jsonapi-resources'
+
+class ApplicationController < ActionController::Base
+end
+
+# prepare jsonapi resources and controllers
+class YourModelsController < ApplicationController
+  include JSONAPI::ActsAsResourceController
+end
+
+class YourModelResource < JSONAPI::Resource
+  attribute :name
+  filter :name
+end
+
+class TestApp < Rails::Application
+  config.root = File.dirname(__FILE__)
+  config.logger = Logger.new(STDOUT)
+  Rails.logger = config.logger
+
+  secrets.secret_token = 'secret_token'
+  secrets.secret_key_base = 'secret_key_base'
+
+  config.eager_load = false
+end
+
+# initialize app
+Rails.application.initialize!
+
+JSONAPI.configure do |config|
+  config.json_key_format = :underscored_key
+  config.route_format = :underscored_key
+end
+
+# draw routes
+Rails.application.routes.draw do
+  jsonapi_resources :your_models, only: [:index, :create]
+end
+
+# prepare tests
+require 'minitest/autorun'
+require 'rack/test'
+
+# Replace this with the code necessary to make your test fail.
+class BugTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def json_api_headers
+    {'Accept' => JSONAPI::MEDIA_TYPE, 'CONTENT_TYPE' => JSONAPI::MEDIA_TYPE}
+  end
+
+  def test_index_your_models
+    record = YourModel.create! name: 'John Doe'
+    get '/your_models', nil, json_api_headers
+    assert last_response.ok?
+    json_response = JSON.parse(last_response.body)
+    refute_nil json_response['data']
+    refute_empty json_response['data']
+    refute_empty json_response['data'].first
+    assert record.id.to_s, json_response['data'].first['id']
+    assert 'your_models', json_response['data'].first['type']
+    assert({'name' => 'John Doe'}, json_response['data'].first['attributes'])
+  end
+
+  def test_create_your_models
+    json_request = {
+        'data' => {
+            type: 'your_models',
+            attributes: {
+                name: 'Jane Doe'
+            }
+        }
+    }
+    post '/your_models', json_request.to_json, json_api_headers
+    assert last_response.created?
+    refute_nil YourModel.find_by(name: 'Jane Doe')
+  end
+
+  private
+
+  def app
+    Rails.application
+  end
+end

data/lib/bug_report_templates/rails_5_master.rb

@@ -0,0 +1,140 @@
+begin
+  require 'bundler/inline'
+  require 'bundler'
+rescue LoadError => e
+  STDERR.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
+  raise e
+end
+
+gemfile(true, ui: ENV['SILENT'] ? Bundler::UI::Silent.new : Bundler::UI::Shell.new) do
+  source 'https://rubygems.org'
+
+  gem 'rails', require: false
+  gem 'sqlite3', platform: :mri
+
+  gem 'activerecord-jdbcsqlite3-adapter',
+      git: 'https://github.com/jruby/activerecord-jdbc-adapter',
+      branch: 'rails-5',
+      platform: :jruby
+
+  if ENV['JSONAPI_RESOURCES_PATH']
+    gem 'jsonapi-resources', path: ENV['JSONAPI_RESOURCES_PATH'], require: false
+  else
+    gem 'jsonapi-resources', git: 'https://github.com/cerebris/jsonapi-resources', require: false
+  end
+
+end
+
+# prepare active_record database
+require 'active_record'
+
+class NullLogger < Logger
+  def initialize(*_args)
+  end
+
+  def add(*_args, &_block)
+  end
+end
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.logger = ENV['SILENT'] ? NullLogger.new : Logger.new(STDOUT)
+ActiveRecord::Migration.verbose = !ENV['SILENT']
+
+ActiveRecord::Schema.define do
+  # Add your schema here
+  create_table :your_models, force: true do |t|
+    t.string :name
+  end
+end
+
+# create models
+class YourModel < ActiveRecord::Base
+end
+
+# prepare rails app
+require 'action_controller/railtie'
+# require 'action_view/railtie'
+require 'jsonapi-resources'
+
+class ApplicationController < ActionController::Base
+end
+
+# prepare jsonapi resources and controllers
+class YourModelsController < ApplicationController
+  include JSONAPI::ActsAsResourceController
+end
+
+class YourModelResource < JSONAPI::Resource
+  attribute :name
+  filter :name
+end
+
+class TestApp < Rails::Application
+  config.root = File.dirname(__FILE__)
+  config.logger = ENV['SILENT'] ? NullLogger.new : Logger.new(STDOUT)
+  Rails.logger = config.logger
+
+  secrets.secret_token = 'secret_token'
+  secrets.secret_key_base = 'secret_key_base'
+
+  config.eager_load = false
+end
+
+# initialize app
+Rails.application.initialize!
+
+JSONAPI.configure do |config|
+  config.json_key_format = :underscored_key
+  config.route_format = :underscored_key
+end
+
+# draw routes
+Rails.application.routes.draw do
+  jsonapi_resources :your_models, only: [:index, :create]
+end
+
+# prepare tests
+require 'minitest/autorun'
+require 'rack/test'
+
+# Replace this with the code necessary to make your test fail.
+class BugTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def json_api_headers
+    {'Accept' => JSONAPI::MEDIA_TYPE, 'CONTENT_TYPE' => JSONAPI::MEDIA_TYPE}
+  end
+
+  def test_index_your_models
+    record = YourModel.create! name: 'John Doe'
+    get '/your_models', nil, json_api_headers
+    assert last_response.ok?
+    json_response = JSON.parse(last_response.body)
+    refute_nil json_response['data']
+    refute_empty json_response['data']
+    refute_empty json_response['data'].first
+    assert record.id.to_s, json_response['data'].first['id']
+    assert 'your_models', json_response['data'].first['type']
+    assert({'name' => 'John Doe'}, json_response['data'].first['attributes'])
+  end
+
+  def test_create_your_models
+    json_request = {
+        'data' => {
+            type: 'your_models',
+            attributes: {
+                name: 'Jane Doe'
+            }
+        }
+    }
+    post '/your_models', json_request.to_json, json_api_headers
+    assert last_response.created?
+    refute_nil YourModel.find_by(name: 'Jane Doe')
+  end
+
+  private
+
+  def app
+    Rails.application
+  end
+end

data/lib/jsonapi/active_relation/adapters/join_left_active_record_adapter.rb

@@ -0,0 +1,26 @@
+module JSONAPI
+  module ActiveRelation
+    module Adapters
+      module JoinLeftActiveRecordAdapter
+        # Extends left_joins functionality to rails 4, and uses the same logic for rails 5.0.x and 5.1.x
+        # The default left_joins logic of rails 5.2.x is used. This results in and extra join in some cases. For
+        # example Post.joins(:comments).joins_left(comments: :author) will join the comments table twice,
+        # once inner and once left in 5.2, but only as inner in earlier versions.
+        def joins_left(*columns)
+          if Rails::VERSION::MAJOR >= 6 || (Rails::VERSION::MAJOR >= 5 && ActiveRecord::VERSION::MINOR >= 2)
+            left_joins(columns)
+          else
+            join_dependency = ActiveRecord::Associations::JoinDependency.new(self, columns, [])
+            joins(join_dependency)
+          end
+         end
+
+        alias_method :join_left, :joins_left
+      end
+
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.extend JoinLeftActiveRecordAdapter
+      end
+    end
+  end
+end

data/lib/jsonapi/active_relation/join_manager.rb

@@ -0,0 +1,297 @@
+module JSONAPI
+  module ActiveRelation
+
+  # Stores relationship paths starting from the resource_klass, consolidating duplicate paths from
+  # relationships, filters and sorts. When joins are made the table aliases are tracked in join_details
+  class JoinManager
+      attr_reader :resource_klass,
+                  :source_relationship,
+                  :resource_join_tree,
+                  :join_details
+
+      def initialize(resource_klass:,
+                     source_relationship: nil,
+                     relationships: nil,
+                     filters: nil,
+                     sort_criteria: nil)
+
+        @resource_klass = resource_klass
+        @join_details = nil
+        @collected_aliases = Set.new
+
+        @resource_join_tree = {
+            root: {
+                join_type: :root,
+                resource_klasses: {
+                    resource_klass => {
+                        relationships: {}
+                    }
+                }
+            }
+        }
+        add_source_relationship(source_relationship)
+        add_sort_criteria(sort_criteria)
+        add_filters(filters)
+        add_relationships(relationships)
+      end
+
+      def join(records, options)
+        fail "can't be joined again" if @join_details
+        @join_details = {}
+        perform_joins(records, options)
+      end
+
+      # source details will only be on a relationship if the source_relationship is set
+      # this method gets the join details whether they are on a relationship or are just pseudo details for the base
+      # resource. Specify the resource type for polymorphic relationships
+      #
+      def source_join_details(type=nil)
+        if source_relationship
+          related_resource_klass = type ? resource_klass.resource_klass_for(type) : source_relationship.resource_klass
+          segment = PathSegment::Relationship.new(relationship: source_relationship, resource_klass: related_resource_klass)
+          details = @join_details[segment]
+        else
+          if type
+            details = @join_details["##{type}"]
+          else
+            details = @join_details['']
+          end
+        end
+        details
+      end
+
+      def join_details_by_polymorphic_relationship(relationship, type)
+        segment = PathSegment::Relationship.new(relationship: relationship, resource_klass: resource_klass.resource_klass_for(type))
+        @join_details[segment]
+      end
+
+      def join_details_by_relationship(relationship)
+        segment = PathSegment::Relationship.new(relationship: relationship, resource_klass: relationship.resource_klass)
+        @join_details[segment]
+      end
+
+      def self.get_join_arel_node(records, options = {})
+        init_join_sources = records.arel.join_sources
+        init_join_sources_length = init_join_sources.length
+
+        records = yield(records, options)
+
+        join_sources = records.arel.join_sources
+        if join_sources.length > init_join_sources_length
+          last_join = (join_sources - init_join_sources).last
+        else
+          # :nocov:
+          warn "get_join_arel_node: No join added"
+          last_join = nil
+          # :nocov:
+        end
+
+        return records, last_join
+      end
+
+      def self.alias_from_arel_node(node)
+        case node.left
+        when Arel::Table
+          node.left.name
+        when Arel::Nodes::TableAlias
+          node.left.right
+        when Arel::Nodes::StringJoin
+          # :nocov:
+          warn "alias_from_arel_node: Unsupported join type - use custom filtering and sorting"
+          nil
+          # :nocov:
+        end
+      end
+
+      private
+
+      def flatten_join_tree_by_depth(join_array = [], node = @resource_join_tree, level = 0)
+        join_array[level] = [] unless join_array[level]
+
+        node.each do |relationship, relationship_details|
+          relationship_details[:resource_klasses].each do |related_resource_klass, resource_details|
+            join_array[level] << { relationship: relationship,
+                                   relationship_details: relationship_details,
+                                   related_resource_klass: related_resource_klass}
+            flatten_join_tree_by_depth(join_array, resource_details[:relationships], level+1)
+          end
+        end
+        join_array
+      end
+
+      def add_join_details(join_key, details, check_for_duplicate_alias = true)
+        fail "details already set" if @join_details.has_key?(join_key)
+        @join_details[join_key] = details
+
+        # Joins are being tracked as they are added to the built up relation. If the same table is added to a
+        # relation more than once subsequent versions will be assigned an alias. Depending on the order the joins
+        # are made the computed aliases may change. The order this library performs the joins was chosen
+        # to prevent this. However if the relation is reordered it should result in reusing on of the earlier
+        # aliases (in this case a plain table name). The following check will catch this an raise an exception.
+        # An exception is appropriate because not using the correct alias could leak data due to filters and
+        # applied permissions being performed on the wrong data.
+        if check_for_duplicate_alias && @collected_aliases.include?(details[:alias])
+          fail "alias '#{details[:alias]}' has already been added. Possible relation reordering"
+        end
+
+        @collected_aliases << details[:alias]
+      end
+
+      def perform_joins(records, options)
+        join_array = flatten_join_tree_by_depth
+
+        join_array.each do |level_joins|
+          level_joins.each do |join_details|
+            relationship = join_details[:relationship]
+            relationship_details = join_details[:relationship_details]
+            related_resource_klass = join_details[:related_resource_klass]
+            join_type = relationship_details[:join_type]
+
+            if relationship == :root
+              unless source_relationship
+                add_join_details('', {alias: resource_klass._table_name, join_type: :root})
+              end
+              next
+            end
+
+            records, join_node = self.class.get_join_arel_node(records, options) {|records, options|
+              related_resource_klass.join_relationship(
+                records: records,
+                resource_type: related_resource_klass._type,
+                join_type: join_type,
+                relationship: relationship,
+                options: options)
+            }
+
+            details = {alias: self.class.alias_from_arel_node(join_node), join_type: join_type}
+
+            if relationship == source_relationship
+              if relationship.polymorphic? && relationship.belongs_to?
+                add_join_details("##{related_resource_klass._type}", details)
+              else
+                add_join_details('', details)
+              end
+            end
+
+            # We're adding the source alias with two keys. We only want the check for duplicate aliases once.
+            # See the note in `add_join_details`.
+            check_for_duplicate_alias = !(relationship == source_relationship)
+            add_join_details(PathSegment::Relationship.new(relationship: relationship, resource_klass: related_resource_klass), details, check_for_duplicate_alias)
+          end
+        end
+        records
+      end
+
+      def add_join(path, default_type = :inner, default_polymorphic_join_type = :left)
+        if source_relationship
+          if source_relationship.polymorphic?
+            # Polymorphic paths will come it with the resource_type as the first segment (for example `#documents.comments`)
+            # We just need to prepend the relationship portion the
+            sourced_path = "#{source_relationship.name}#{path}"
+          else
+            sourced_path = "#{source_relationship.name}.#{path}"
+          end
+        else
+          sourced_path = path
+        end
+
+        join_manager, _field = parse_path_to_tree(sourced_path, resource_klass, default_type, default_polymorphic_join_type)
+
+        @resource_join_tree[:root].deep_merge!(join_manager) { |key, val, other_val|
+          if key == :join_type
+            if val == other_val
+              val
+            else
+              :inner
+            end
+          end
+        }
+      end
+
+      def process_path_to_tree(path_segments, resource_klass, default_join_type, default_polymorphic_join_type)
+        node = {
+            resource_klasses: {
+                resource_klass => {
+                    relationships: {}
+                }
+            }
+        }
+
+        segment = path_segments.shift
+
+        if segment.is_a?(PathSegment::Relationship)
+          node[:resource_klasses][resource_klass][:relationships][segment.relationship] ||= {}
+
+          # join polymorphic as left joins
+          node[:resource_klasses][resource_klass][:relationships][segment.relationship][:join_type] ||=
+              segment.relationship.polymorphic? ? default_polymorphic_join_type : default_join_type
+
+          segment.relationship.resource_types.each do |related_resource_type|
+            related_resource_klass = resource_klass.resource_klass_for(related_resource_type)
+
+            # If the resource type was specified in the path segment we want to only process the next segments for
+            # that resource type, otherwise process for all
+            process_all_types = !segment.path_specified_resource_klass?
+
+            if process_all_types || related_resource_klass == segment.resource_klass
+              related_resource_tree = process_path_to_tree(path_segments.dup, related_resource_klass, default_join_type, default_polymorphic_join_type)
+              node[:resource_klasses][resource_klass][:relationships][segment.relationship].deep_merge!(related_resource_tree)
+            end
+          end
+        end
+        node
+      end
+
+      def parse_path_to_tree(path_string, resource_klass, default_join_type = :inner, default_polymorphic_join_type = :left)
+        path = JSONAPI::Path.new(resource_klass: resource_klass, path_string: path_string)
+
+        field = path.segments[-1]
+        return process_path_to_tree(path.segments, resource_klass, default_join_type, default_polymorphic_join_type), field
+      end
+
+      def add_source_relationship(source_relationship)
+        @source_relationship = source_relationship
+
+        if @source_relationship
+          resource_klasses = {}
+          source_relationship.resource_types.each do |related_resource_type|
+            related_resource_klass = resource_klass.resource_klass_for(related_resource_type)
+            resource_klasses[related_resource_klass] = {relationships: {}}
+          end
+
+          join_type = source_relationship.polymorphic? ? :left : :inner
+
+          @resource_join_tree[:root][:resource_klasses][resource_klass][:relationships][@source_relationship] = {
+              source: true, resource_klasses: resource_klasses, join_type: join_type
+          }
+        end
+      end
+
+      def add_filters(filters)
+        return if filters.blank?
+        filters.each_key do |filter|
+          # Do not add joins for filters with an apply callable. This can be overridden by setting perform_joins to true
+          next if resource_klass._allowed_filters[filter].try(:[], :apply) &&
+              !resource_klass._allowed_filters[filter].try(:[], :perform_joins)
+
+          add_join(filter, :left)
+        end
+      end
+
+      def add_sort_criteria(sort_criteria)
+        return if sort_criteria.blank?
+
+        sort_criteria.each do |sort|
+          add_join(sort[:field], :left)
+        end
+      end
+
+      def add_relationships(relationships)
+        return if relationships.blank?
+        relationships.each do |relationship|
+          add_join(relationship, :left)
+        end
+      end
+    end
+  end
+end