jsonapi-resources 0.9.0 → 0.9.12

data/lib/jsonapi/resource_serializer.rb

@@ -90,20 +90,19 @@ module JSONAPI
       primary_hash
     end
 
-    def serialize_to_links_hash(source, requested_relationship)
+    def serialize_to_relationship_hash(source, requested_relationship)
       if requested_relationship.is_a?(JSONAPI::Relationship::ToOne)
         data = to_one_linkage(source, requested_relationship)
       else
         data = to_many_linkage(source, requested_relationship)
       end
 
-      {
-        links: {
-          self: self_link(source, requested_relationship),
-          related: related_link(source, requested_relationship)
-        },
-        data: data
-      }
+      rel_hash = { 'data': data }
+
+      links = default_relationship_links(source, requested_relationship)
+      rel_hash['links'] = links unless links.blank?
+
+      rel_hash
     end
 
     def query_link(query_params)
@@ -133,7 +132,6 @@ module JSONAPI
         supplying_attribute_fields: supplying_attribute_fields(resource_klass).sort,
         supplying_relationship_fields: supplying_relationship_fields(resource_klass).sort,
         link_builder_base_url: link_builder.base_url,
-        route_formatter_class: link_builder.route_formatter.uncached.class.name,
         key_formatter_class: key_formatter.uncached.class.name,
         always_include_to_one_linkage_data: always_include_to_one_linkage_data,
         always_include_to_many_linkage_data: always_include_to_many_linkage_data
@@ -152,7 +150,7 @@ module JSONAPI
         obj_hash['attributes'] = source.attributes_json if source.attributes_json
 
         relationships = cached_relationships_hash(source, include_directives)
-        obj_hash['relationships'] = relationships unless relationships.empty?
+        obj_hash['relationships'] = relationships unless relationships.blank?
 
         obj_hash['meta'] = source.meta_json if source.meta_json
       else
@@ -173,7 +171,7 @@ module JSONAPI
         obj_hash['attributes'] = attributes unless attributes.empty?
 
         relationships = relationships_hash(source, fetchable_fields, include_directives)
-        obj_hash['relationships'] = relationships unless relationships.nil? || relationships.empty?
+        obj_hash['relationships'] = relationships unless relationships.blank?
 
         meta = meta_hash(source)
         obj_hash['meta'] = meta unless meta.empty?
@@ -251,7 +249,9 @@ module JSONAPI
 
     def links_hash(source)
       links = custom_links_hash(source)
-      links[:self] = link_builder.self_link(source) unless links.key?(:self)
+      if !links.key?('self') && !source.class.exclude_link?(:self)
+        links['self'] = link_builder.self_link(source)
+      end
       links.compact
     end
 
@@ -288,7 +288,8 @@ module JSONAPI
         include_linked_children = ia && !ia[:include_related].empty?
 
         if field_set.include?(name)
-          hash[format_key(name)] = link_object(source, relationship, include_linkage)
+          ro = relationship_object(source, relationship, include_linkage)
+          hash[format_key(name)] = ro unless ro.blank?
         end
 
         # If the object has been serialized once it will be in the related objects list,
@@ -298,7 +299,8 @@ module JSONAPI
           resources = if source.preloaded_fragments.has_key?(format_key(name))
             source.preloaded_fragments[format_key(name)].values
           else
-            [source.public_send(name)].flatten(1).compact
+            options = { filters: ia && ia[:include_filters] || {} }
+            [source.public_send(name, options)].flatten(1).compact
           end
           resources.each do |resource|
             next if self_referential_and_already_in_source(resource)
@@ -380,6 +382,13 @@ module JSONAPI
       link_builder.relationships_related_link(source, relationship)
     end
 
+    def default_relationship_links(source, relationship)
+      links = {}
+      links['self'] = self_link(source, relationship) unless relationship.exclude_link?(:self)
+      links['related'] = related_link(source, relationship) unless relationship.exclude_link?(:related)
+      links.compact
+    end
+
     def to_one_linkage(source, relationship)
       linkage_id = foreign_key_value(source, relationship)
       linkage_type = format_key(relationship.type_for_source(source))
@@ -393,24 +402,29 @@ module JSONAPI
 
     def to_many_linkage(source, relationship)
       linkage = []
+      include_config = include_directives.include_config(relationship.name.to_sym) if include_directives
+      include_filters = include_config[:include_filters] if include_config
+      options = { filters: include_filters || {} }
+
       linkage_types_and_values = if source.preloaded_fragments.has_key?(format_key(relationship.name))
         source.preloaded_fragments[format_key(relationship.name)].map do |_, resource|
           [relationship.type, resource.id]
         end
       elsif relationship.polymorphic?
-        assoc = source._model.public_send(relationship.name)
+        assoc = source.public_send("records_for_#{relationship.name}", options)
         # Avoid hitting the database again for values already pre-loaded
         if assoc.respond_to?(:loaded?) and assoc.loaded?
           assoc.map do |obj|
             [obj.type.underscore.pluralize, obj.id]
           end
         else
+          assoc = assoc.unscope(:includes) if assoc.is_a?(ActiveRecord::Relation)
           assoc.pluck(:type, :id).map do |type, id|
             [type.underscore.pluralize, id]
           end
         end
       else
-        source.public_send(relationship.name).map do |value|
+        source.public_send(relationship.name, options).map do |value|
           [relationship.type, value.id]
         end
       end
@@ -423,46 +437,51 @@ module JSONAPI
       linkage
     end
 
-    def link_object_to_one(source, relationship, include_linkage)
+    def relationship_object_to_one(source, relationship, include_linkage)
       include_linkage = include_linkage | @always_include_to_one_linkage_data | relationship.always_include_linkage_data
-      link_object_hash = {}
-      link_object_hash[:links] = {}
-      link_object_hash[:links][:self] = self_link(source, relationship)
-      link_object_hash[:links][:related] = related_link(source, relationship)
-      link_object_hash[:data] = to_one_linkage(source, relationship) if include_linkage
-      link_object_hash
+      relationship_object_hash = {}
+
+      links = default_relationship_links(source, relationship)
+
+      relationship_object_hash['links'] = links unless links.blank?
+      relationship_object_hash[:data] = to_one_linkage(source, relationship) if include_linkage
+      relationship_object_hash
     end
 
-    def link_object_to_many(source, relationship, include_linkage)
+    def relationship_object_to_many(source, relationship, include_linkage)
       include_linkage = include_linkage | relationship.always_include_linkage_data
-      link_object_hash = {}
-      link_object_hash[:links] = {}
-      link_object_hash[:links][:self] = self_link(source, relationship)
-      link_object_hash[:links][:related] = related_link(source, relationship)
-      link_object_hash[:data] = to_many_linkage(source, relationship) if include_linkage
-      link_object_hash
+      relationship_object_hash = {}
+
+      links = default_relationship_links(source, relationship)
+      relationship_object_hash['links'] = links unless links.blank?
+      relationship_object_hash[:data] = to_many_linkage(source, relationship) if include_linkage
+      relationship_object_hash
     end
 
-    def link_object(source, relationship, include_linkage = false)
+    def relationship_object(source, relationship, include_linkage = false)
       if relationship.is_a?(JSONAPI::Relationship::ToOne)
-        link_object_to_one(source, relationship, include_linkage)
+        relationship_object_to_one(source, relationship, include_linkage)
       elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
-        link_object_to_many(source, relationship, include_linkage)
+        relationship_object_to_many(source, relationship, include_linkage)
       end
     end
 
     # Extracts the foreign key value for a to_one relationship.
     def foreign_key_value(source, relationship)
-      related_resource_id = if source.preloaded_fragments.has_key?(format_key(relationship.name))
-        source.preloaded_fragments[format_key(relationship.name)].values.first.try(:id)
-      elsif source.respond_to?("#{relationship.name}_id")
-        # If you have direct access to the underlying id, you don't have to load the relationship
-        # which can save quite a lot of time when loading a lot of data.
-        # This does not apply to e.g. has_one :through relationships.
-        source.public_send("#{relationship.name}_id")
-      else
-        source.public_send(relationship.name).try(:id)
-      end
+      # If you have changed the key_name, don't even try to look at `"#{relationship.name}_id"`
+      # just load the association and call the custom key_name
+      foreign_key_type_changed = relationship.options[:foreign_key_type_changed] || false
+      related_resource_id =
+        if source.preloaded_fragments.has_key?(format_key(relationship.name))
+          source.preloaded_fragments[format_key(relationship.name)].values.first.try(:id)
+        elsif !foreign_key_type_changed && source.respond_to?("#{relationship.name}_id")
+          # If you have direct access to the underlying id, you don't have to load the relationship
+          # which can save quite a lot of time when loading a lot of data.
+          # This does not apply to e.g. has_one :through relationships.
+          source.public_send("#{relationship.name}_id")
+        else
+          source.public_send(relationship.name).try(:id)
+        end
       return nil unless related_resource_id
       @id_formatter.format(related_resource_id)
     end
@@ -523,8 +542,9 @@ module JSONAPI
     def generate_link_builder(primary_resource_klass, options)
       LinkBuilder.new(
         base_url: options.fetch(:base_url, ''),
-        route_formatter: options.fetch(:route_formatter, JSONAPI.configuration.route_formatter),
         primary_resource_klass: primary_resource_klass,
+        route_formatter: options.fetch(:route_formatter, JSONAPI.configuration.route_formatter),
+        url_helpers: options.fetch(:url_helpers, options[:controller]),
       )
     end
   end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.9.0'
+    VERSION = '0.9.12'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -64,14 +64,19 @@ module JSONAPI
 
         # Build pagination links
         if result.is_a?(JSONAPI::ResourcesOperationResult) || result.is_a?(JSONAPI::RelatedResourcesOperationResult)
-            result.pagination_params.each_pair do |link_name, params|
-              if result.is_a?(JSONAPI::RelatedResourcesOperationResult)
-                relationship = result.source_resource.class._relationships[result._type.to_sym]
-                links[link_name] = @serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
-              else
-                links[link_name] = @serializer.query_link(query_params(params))
+          result.pagination_params.each_pair do |link_name, params|
+            if result.is_a?(JSONAPI::RelatedResourcesOperationResult)
+              relationship = result.source_resource.class._relationships[result._type.to_sym]
+              unless relationship.exclude_link?(link_name)
+                link = @serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
+              end
+            else
+              unless @serializer.link_builder.primary_resource_klass.exclude_link?(link_name)
+                link = @serializer.link_builder.query_link(query_params(params))
               end
             end
+            links[link_name] = link unless link.blank?
+          end
         end
       end
 
@@ -109,9 +114,9 @@ module JSONAPI
             @serializer.serialize_to_hash(result.resource)
           when JSONAPI::ResourcesOperationResult
             @serializer.serialize_to_hash(result.resources)
-          when JSONAPI::LinksObjectOperationResult
-            @serializer.serialize_to_links_hash(result.parent_resource,
-                                               result.relationship)
+          when JSONAPI::RelationshipOperationResult
+            @serializer.serialize_to_relationship_hash(result.parent_resource,
+                                                       result.relationship)
           when JSONAPI::OperationResult
             {}
           end

data/lib/jsonapi/routing_ext.rb

@@ -20,6 +20,12 @@ module ActionDispatch
           @resource_type = resources.first
           res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
 
+          res._routed = true
+
+          unless res.singleton?
+            warn "Singleton routes created for non singleton resource #{res}. Links may not be generated correctly."
+          end
+
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
           options.merge!(res.routing_resource_options)
@@ -80,6 +86,12 @@ module ActionDispatch
           @resource_type = resources.first
           res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
 
+          res._routed = true
+
+          if res.singleton?
+            warn "Singleton resource #{res} should use `jsonapi_resource` instead."
+          end
+
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
           options.merge!(res.routing_resource_options)
@@ -153,19 +165,23 @@ module ActionDispatch
           methods = links_methods(options)
 
           if methods.include?(:show)
-            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+            match "relationships/#{formatted_relationship_name}",
+                  controller: options[:controller],
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
             if methods.include?(:update)
-              match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+              match "relationships/#{formatted_relationship_name}",
+                    controller: options[:controller],
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
-              match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+              match "relationships/#{formatted_relationship_name}",
+                    controller: options[:controller],
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
@@ -182,23 +198,24 @@ module ActionDispatch
 
           if methods.include?(:show)
             match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
             if methods.include?(:create)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
+                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
             end
 
             if methods.include?(:update)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                          action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
@@ -210,6 +227,8 @@ module ActionDispatch
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
 
           if relationship.polymorphic?
@@ -219,9 +238,10 @@ module ActionDispatch
             options[:controller] ||= related_resource._type.to_s
           end
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resource', via: [:get]
+          match formatted_relationship_name, controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'get_related_resource', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         def jsonapi_related_resources(*relationship)
@@ -231,13 +251,17 @@ module ActionDispatch
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
           related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore))
           options[:controller] ||= related_resource._type.to_s
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resources', via: [:get]
+          match formatted_relationship_name,
+                controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'get_related_resources', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         protected

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.12
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-14 00:00:00.000000000 Z
+date: 2021-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +109,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -216,8 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Easily support JSON API in Rails.