jsonapi-resources 0.10.7 → 0.11.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d30a2ea26f6bb9f907e0710a7e9d95a9682bfa64ab0fd7ae1e5b350c07f52924
-  data.tar.gz: fd883de5a6506f4aaad03fcf3ec61ec311c0e57f0cf33ea8c3d8b082c47b2671
+  metadata.gz: 3b0c18d478ae14531738238de633c47aace50c6f7a2c3ff25e9ce09033e802ce
+  data.tar.gz: 8365f223895635d28c12ecf334193ed4f3a30368a3a4d674fc5e65366f3d317f
 SHA512:
-  metadata.gz: cc53b7071fb93b2f2f5c8ff2f02b43572a56d5da8a58835cff73953100db55c0ea9dbc2a1d26b7b06ae854d8e588276619d7631a4dc509e7c6332b9ced5c6245
-  data.tar.gz: d9f77c39f058f3978b20ccba5d2beea4744bbda9cb1b19933ed9a3a235a5265a9fecb945a2fd3646f0135cb97059896be3ac2fa19023a94fd555480ac8483f95
+  metadata.gz: d06fbbf825b5123ef5bef84de20f5a30ea7ea352bb82a0db56a13f84cc90ff289290c40928d7155adeabd78fc0ef4011013b0015bb6a49703364e9c4cb814eb9
+  data.tar.gz: c112c3947eb59fd53475ac8f9483a1754dd01677f1854ff44bc751b0d4adeb1cef5d49e99f6ef166af0335eef3f3e66719fd58cb4092723348a7aa2be3222677

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2017 Cerebris Corporation
+Copyright (c) 2014-2023 Cerebris Corporation
 
 MIT License
 

data/README.md

@@ -8,7 +8,7 @@
 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
@@ -46,6 +46,43 @@ gem install jsonapi-resources
 
 **For further usage see the [v0.10 alpha Guide](http://jsonapi-resources.com/v0.10/guide/)**
 
+## Development
+
+There is a docker compose setup that can be used for testing your code against the supported versions of ruby and
+against PostgreSQL, MYSQL, and SQLite databases.
+
+First build the docker image:
+```bash
+docker compose build
+```
+Be sure to rebuild after making code changes. It should be fast after the initial build.
+
+### Running the tests
+
+The default command will run everything (it may take a while):
+```bash
+docker compose run tests
+```
+
+To test just one database against the latest ruby:
+```bash
+docker compose run tests ./test_mysql
+docker compose run tests ./test_postgresql
+docker compose run tests ./test_sqlite
+```
+
+To test a version of ruby against all databases:
+```bash
+docker compose run tests ./test_ruby 2.7.7
+```
+
+The tests by default run against the latest rails version. To override that you can set the RAILS_VERSION environment
+variable:
+
+```bash
+docker compose run -e RAILS_VERSION=6.1.1 tests ./test_postgresql
+```
+
 ## Contributing
 
 1. Submit an issue describing any new features you wish it add or the bug you intend to fix
@@ -73,4 +110,4 @@ and **paste the content into the issue description or attach as a file**:
 
 ## License
 
-Copyright 2014-2017 Cerebris Corporation. MIT License (see LICENSE for details).
+Copyright 2014-2023 Cerebris Corporation. MIT License (see LICENSE for details).

data/lib/generators/jsonapi/controller_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jsonapi
   class ControllerGenerator < Rails::Generators::NamedBase
     source_root File.expand_path('../templates', __FILE__)

data/lib/generators/jsonapi/resource_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jsonapi
   class ResourceGenerator < Rails::Generators::NamedBase
     source_root File.expand_path('../templates', __FILE__)

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 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,
@@ -24,4 +25,4 @@ module JSONAPI
       end
     end
   end
-end
+end

data/lib/jsonapi/active_relation/join_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module ActiveRelation
 
@@ -7,17 +9,22 @@ module JSONAPI
       attr_reader :resource_klass,
                   :source_relationship,
                   :resource_join_tree,
-                  :join_details
+                  :join_details,
+                  :through_source
 
       def initialize(resource_klass:,
                      source_relationship: nil,
+                     source_resource_klass: nil,
+                     through_source: false,
                      relationships: nil,
                      filters: nil,
                      sort_criteria: nil)
 
         @resource_klass = resource_klass
+        @source_resource_klass = source_resource_klass
         @join_details = nil
         @collected_aliases = Set.new
+        @through_source = through_source
 
         @resource_join_tree = {
             root: {
@@ -45,7 +52,7 @@ module JSONAPI
       # 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)
+      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)
@@ -90,14 +97,20 @@ module JSONAPI
       end
 
       def self.alias_from_arel_node(node)
-        case node.left
+        # case node.left
+        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"
+          warn "alias_from_arel_node: Unsupported join type `Arel::Nodes::StringJoin` - use custom filtering and sorting"
+          nil
+          # :nocov:
+        else
+          # :nocov:
+          warn "alias_from_arel_node: Unsupported join type `#{node&.left.to_s}`"
           nil
           # :nocov:
         end
@@ -147,15 +160,9 @@ module JSONAPI
             related_resource_klass = join_details[:related_resource_klass]
             join_type = relationship_details[:join_type]
 
-            join_options = {
-              relationship: relationship,
-              relationship_details: relationship_details,
-              related_resource_klass: related_resource_klass,
-            }
-
             if relationship == :root
               unless source_relationship
-                add_join_details('', {alias: resource_klass._table_name, join_type: :root, join_options: join_options})
+                add_join_details('', {alias: resource_klass._table_name, join_type: :root})
               end
               next
             end
@@ -169,7 +176,8 @@ module JSONAPI
                 options: options)
             }
 
-            details = {alias: self.class.alias_from_arel_node(join_node), join_type: join_type, join_options: join_options}
+            join_alias = self.class.alias_from_arel_node(join_node)
+            details = {alias: join_alias, join_type: join_type}
 
             if relationship == source_relationship
               if relationship.polymorphic? && relationship.belongs_to?
@@ -181,15 +189,19 @@ module JSONAPI
 
             # 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)
+            check_for_duplicate_alias = relationship != source_relationship
+            path_segment = PathSegment::Relationship.new(relationship: relationship,
+                                                         resource_klass: related_resource_klass)
+
+            add_join_details(path_segment, details, check_for_duplicate_alias)
           end
         end
         records
       end
 
       def add_join(path, default_type = :inner, default_polymorphic_join_type = :left)
-        if source_relationship
+        # puts "add_join #{path} default_type=#{default_type} default_polymorphic_join_type=#{default_polymorphic_join_type}"
+        if source_relationship && through_source
           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
@@ -201,9 +213,9 @@ module JSONAPI
           sourced_path = path
         end
 
-        join_manager, _field = parse_path_to_tree(sourced_path, resource_klass, default_type, default_polymorphic_join_type)
+        join_tree, _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|
+        @resource_join_tree[:root].deep_merge!(join_tree) { |key, val, other_val|
           if key == :join_type
             if val == other_val
               val
@@ -300,4 +312,4 @@ module JSONAPI
       end
     end
   end
-end
+end

data/lib/jsonapi/active_relation/join_manager_v10.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+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 JoinManagerV10
+      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]
+
+            join_options = {
+              relationship: relationship,
+              relationship_details: relationship_details,
+              related_resource_klass: related_resource_klass,
+            }
+
+            if relationship == :root
+              unless source_relationship
+                add_join_details('', {alias: resource_klass._table_name, join_type: :root, join_options: join_options})
+              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, join_options: join_options}
+
+            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