flexirest 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f6e4ecaa1f891e1bb1a98368b8dbdf39024d31f
-  data.tar.gz: deb3c6a4cbf8af73c9cb2c513866162f7e440071
+  metadata.gz: 4cdc8ff86f82324c82e70c1fb8029e66a935e1ef
+  data.tar.gz: 893d3c0cb2198adbaeb81c77d7d0bd4d2549bf90
 SHA512:
-  metadata.gz: beff9dd048c839bcdadda6c49aadd44e2bcc833ff436edfdb917dc6c9efff64afbc249502909aee8bc200ca06aac9587be41b33f595b316c2dbbab2e675b5b55
-  data.tar.gz: 90054f73fb70d72ba4cef6d87a6dc87683c55e731f47d38839a70b2ad5c98c6fae6486be4ff56c19829bd1234f82094d5eb4d9ebac2ecbe5a1ac282132b0457b
+  metadata.gz: a76ac56123023ec67d94139ec6b39a1fa9b874a412556838d1ac226377f4e65fe9e7c613010bef8f16f38cc5b9cd8c14a101f863633a825476f081b7779398ad
+  data.tar.gz: 7f9adf54d566bd067cd72e7c6ad9792eb676b026dab6483944c48bd114bc3c90a41f3ca3306ba014413f6c124b6035fd1c1de2abf0da60e81fe61437dea051cc

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.7.1
+
+Bugfix:
+
+- Fixed fetching nested associations from the compound document when using JsonAPI standard requests (thanks to Mike Voets for the PR)
+
 ## 1.7.0
 
 Feature:

data/lib/flexirest/json_api_proxy.rb

@@ -186,6 +186,7 @@ module Flexirest
     module Response
       extend self
       extend Flexirest::JsonAPIProxy::Helpers
+      ID_PFIX = '_id_'
 
       def save_resource_class(object)
         @resource_class = object.is_a?(Class) ? object : object.class
@@ -206,19 +207,20 @@ module Flexirest
         records = [records] if is_singular_record
 
         # Retrieve all names of linked relationships
-        if records.first['relationships']
-          relationships = records.first['relationships'].keys
-        end
+        relationships = records.first['relationships']
+        relationships = relationships ? relationships.keys : []
 
-        resource_type = records.first['type']
         included = body['included']
 
         # Parse the records, and retrieve all resources in a
         # (nested) array of resources that is easy to work with in Flexirest
         resources = records.map do |record|
-          fetch_attributes_and_relationships(
-            resource_type, record, included, relationships
-          )
+          fetch_attributes_and_relationships(record, included, relationships)
+        end
+
+        # Pluck all attributed and associations into hashes
+        resources = resources.map do |resource|
+          pluck_attributes_and_relationships(resource, relationships)
         end
 
         # Depending on whether we got a resource object (hash) or array
@@ -228,8 +230,9 @@ module Flexirest
 
       private
 
-      def fetch_attributes_and_relationships(base, record, included, rels)
-        rels = (rels || []) - [base]
+      def fetch_attributes_and_relationships(record, included, rels, base: nil)
+        base = Array(base) unless base.is_a?(Array)
+        rels = rels - [base.last]
         rels_object = record['relationships']
 
         rels.each do |rel_name|
@@ -241,16 +244,13 @@ module Flexirest
           if is_singular_rel
             # Fetch a linked resource from the relationships object
             # and add it as an association attribute in the resource hash
-            record[rel_name], embedded = fetch_one_to_one(
-              rels_object, rel_name, included
-            )
-
+            record[rel_name], record[ID_PFIX + rel_name], embedded =
+              fetch_one_to_one(base, rels_object, rel_name, included)
           else
             # Fetch linked resources from the relationships object
             # and add it as an array into the resource hash
-            record[rel_name], embedded = fetch_one_to_many(
-              rels_object, rel_name, included
-            )
+            record[rel_name], record[ID_PFIX + rel_name], embedded =
+              fetch_one_to_many(base, rels_object, rel_name, included)
           end
 
           # Do not try to fetch embedded results if the response is not
@@ -267,49 +267,27 @@ module Flexirest
             if nested_rels_object && nested_rels_object.keys.present?
               # Fetch the linked resources and its attributes recursively
               fetch_attributes_and_relationships(
-                record['type'], nested_record, included, nested_rels_object.keys
+                nested_record, included, nested_rels_object.keys,
+                base: base + [rel_name]
               )
-
             else
-              # If there are no nested linked resources, just fetch the
-              # resource attributes of the linked resource
-              fetch_and_delete_attributes(nested_record)
+              nested_record
             end
           end
 
-          # Depending on if the resource is singular or plural, add it as
-          # the original type (array or hash) into the record hash
-          record[rel_name] =
-            if is_singular_rel
-              linked_resources.first
-            else
-              linked_resources
-            end
+          record[rel_name] = linked_resources
         end
 
-        # Add the record attributes to the record hash
-        fetch_and_delete_attributes(record)
         record
       end
 
-      def fetch_one_to_one(relationships, name, included)
+      def fetch_one_to_one(base, relationships, name, included)
         # Parse the relationships object given the relationship name `name`,
         # and look into the included object (in case of a compound document),
         # to embed the linked resource into the response
 
         if included.blank? || relationships[name]['data'].blank?
-          begin
-            # When the response is not a compound document (i.e. there is no
-            # includes object), build a LazyAssociationLoader for lazy loading
-            return build_lazy_loader(
-              name, relationships[name]['links']['related']
-            ), false
-          rescue NoMethodError
-            # If the url for retrieving the linked resource is missing,
-            # we assume there is no linked resource available to fetch
-            # Default nulled linked resource is `nil`
-            return nil, false
-          end
+          return build_lazy_loader(base, relationships, name), nil, false
         end
 
         # Retrieve the linked resource id and its pluralized type name
@@ -322,69 +300,118 @@ module Flexirest
           i['id'] == rel_id && i['type'] == plural_name
         end
 
-        return linked_resource, true
+        return linked_resource, rel_id, true
       end
 
-      def fetch_one_to_many(relationships, name, included)
+      def fetch_one_to_many(base, relationships, name, included)
         # Parse the relationships object given the relationship name `name`,
         # and look into the included object (in case of a compound document),
         # to embed the linked resources into the response
-
         if included.blank? || relationships[name]['data'].blank?
-          begin
-            # When the response is not a compound document (i.e. there is no
-            # includes object), build a LazyAssociationLoader for lazy loading
-            return build_lazy_loader(
-              name, relationships[name]['links']['related']
-            ), false
-          rescue NoMethodError
-            # If the url for retrieving the linked resources is missing,
-            # we assume there are no linked resources available to fetch
-            # Default nulled linked resources is an empty array
-            return [], false
-          end
+          return build_lazy_loader(base, relationships, name), [], false
         end
 
         # Retrieve the linked resources ids
         rel_ids = relationships[name]['data'].map { |r| r['id'] }
+        plural_name = name.pluralize
 
         # Traverse through the included object, and find the included
         # linked resources, based on the given ids and type name
         linked_resources = included.select do |i|
-          rel_ids.include?(i['id']) && i['type'] == name
+          rel_ids.include?(i['id']) && i['type'] == plural_name
         end
 
-        return linked_resources, true
+        return linked_resources, rel_ids, true
       end
 
-      def fetch_and_delete_attributes(record)
+      def pluck_attributes_and_relationships(record, rels)
+        cleaned = { id: record['id'] }
+        relationships = Hash[rels.map { |rel| [rel, singular?(rel)] }]
+
+        relationships.each do |rel_name, is_singular|
+          safe_name = rel_name.underscore
+          id_sfix = is_singular ? '_id' : '_ids'
+          cleaned[safe_name.singularize + id_sfix] = record[ID_PFIX + rel_name]
+
+          links = record[rel_name]
+          is_lazy_loader = links.is_a?(Flexirest::LazyAssociationLoader)
+
+          linked_resources =
+            if is_lazy_loader || links.blank?
+              # Skip this relationship if it hasn't been included
+              links
+            else
+              # Probe the linked resources
+              first_linked = links.first
+
+              # Retrieve all names of linked relationships
+              nested_rels =
+                if first_linked && first_linked['relationships']
+                  first_linked['relationships'].keys
+                else
+                  []
+                end
+
+              # Recursively pluck attributes for all related resources
+              links.map do |linked_resource|
+                pluck_attributes_and_relationships(linked_resource, nested_rels)
+              end
+            end
+          # Depending on if the resource is singular or plural, add it as
+          # the original type (array or hash) into the record hash
+          cleaned[safe_name] =
+            if is_lazy_loader || !is_singular
+              linked_resources
+            else
+              linked_resources ? linked_resources.first : nil
+            end
+        end
+
         # Fetch attribute keys and values from the resource object
         # and insert into result record hash
         record['attributes'].each do |k, v|
-          record[k] = v
+          cleaned[k.underscore] = v
         end
 
-        delete_keys(record)
-        record
+        cleaned
       end
 
-      def delete_keys(record)
-        # Delete the attribute keys and values from the original response hash
-        record.delete('type')
-        record.delete('links')
-        record.delete('attributes')
-        record.delete('relationships')
+      def find_association_class(base, name)
+        stack = base + [name]
+        klass = @resource_class
+
+        until stack.empty?
+          shift = stack.shift
+          last = klass
+          klass = klass._associations[shift.underscore.to_sym]
+
+          if klass.nil?
+            raise "#{last} has no defined relation to #{shift}. " \
+              "Have you defined :has_one or :has_many :#{shift} in #{last}?"
+          end
+        end
+
+        klass
       end
 
-      def build_lazy_loader(name, url)
+      def build_lazy_loader(base, relationships, name)
+        is_singular = singular?(name)
         # Create a new request, given the linked resource `name`,
         # finding the association's class, and given the `url` to the linked
         # resource
+        begin
+          # When the response is not a compound document (i.e. there is no
+          # includes object), build a LazyAssociationLoader for lazy loading
+          url = relationships[name]['links']['related']
+        rescue NoMethodError
+          # If the url for retrieving the linked resource is missing,
+          # we assume there is no linked resource available to fetch
+          # Default nulled linked resource is `nil` or `[]` for resources
+          return is_singular ? nil : []
+        end
 
-        request = Flexirest::Request.new(
-          { url: url, method: :get },
-          @resource_class._associations[name.to_sym].new
-        )
+        klass = find_association_class(base, name)
+        request = Flexirest::Request.new({ url: url, method: :get }, klass.new)
 
         # Also add the previous request's header, which may contain
         # crucial authentication headers (or so), to connect with the service

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.7.0"
+  VERSION = "1.7.1"
 end

data/spec/lib/json_api_spec.rb

@@ -84,6 +84,24 @@ class JsonAPIExampleArticle < Flexirest::Base
       relationships: { 'tags' => { data: [] }, 'author' => { data: nil } }
     }
   }
+  faker7 = {
+    data: {
+      id: 1, type: 'articles', attributes: { item: 'item one' },
+      relationships: {
+        'tags' => { data: [{ id: 1, type: 'tags' }, { id: 2, type: 'tags' }] },
+        'superman' => {
+          links: {
+            self: 'http://www.example.com/articles/1/relationships/superman',
+            related: 'http://www.example.com/articles/1/superman'
+          }
+        }
+      }
+    },
+    included: [
+      { id: 1, type: 'tags', attributes: { item: 'item two' } },
+      { id: 2, type: 'tags', attributes: { item: 'item three' } }
+    ]
+  }
 
   get(
     :find,
@@ -126,6 +144,13 @@ class JsonAPIExampleArticle < Flexirest::Base
     fake: faker6.to_json,
     fake_content_type: 'application/vnd.api+json'
   )
+
+  get(
+    :not_recognized_assoc,
+    '/articles/:id',
+    fake: faker7.to_json,
+    fake_content_type: 'application/vnd.api+json'
+  )
 end
 
 module JsonAPIExample
@@ -314,6 +339,10 @@ describe 'JSON API' do
       expect(article.find_lazy(1).author).to be_an_instance_of(JsonAPIExample::Author)
       expect(article.find_lazy(1).author.id).to_not be_nil
     end
+
+    it 'should raise exception when an association in the response is not defined in base class' do
+      expect(-> { subject.includes(:tags).not_recognized_assoc(1) }).to raise_error(Exception)
+    end
   end
 
   context 'client' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Andy Jeffries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-05 00:00:00.000000000 Z
+date: 2018-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler