jsonapi-resources 0.10.6 → 0.11.0.beta2

data/lib/jsonapi/resource_set.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   # Contains a hash of resource types which contain a hash of resources, relationships and primary status keyed by
   # resource id.
@@ -5,12 +7,24 @@ module JSONAPI
 
     attr_reader :resource_klasses, :populated
 
-    def initialize(resource_id_tree = nil)
+    def initialize(source, include_related = nil, options = nil)
       @populated = false
-      @resource_klasses = resource_id_tree.nil? ? {} : flatten_resource_id_tree(resource_id_tree)
+      tree = if source.is_a?(JSONAPI::ResourceTree)
+               source
+             elsif source.class.include?(JSONAPI::ResourceCommon)
+               JSONAPI::PrimaryResourceTree.new(resource: source, include_related: include_related, options: options)
+             elsif source.is_a?(Array)
+               JSONAPI::PrimaryResourceTree.new(resources: source, include_related: include_related, options: options)
+             end
+
+      if tree
+        @resource_klasses = flatten_resource_tree(tree)
+      end
     end
 
-    def populate!(serializer, context, find_options)
+    def populate!(serializer, context, options)
+      return if @populated
+
       # For each resource klass we want to generate the caching key
 
       # Hash for collecting types and ids
@@ -21,9 +35,9 @@ module JSONAPI
       # @type [Lookup[]]
       lookups = []
 
-
       # Step One collect all of the lookups for the cache, or keys that don't require cache access
       @resource_klasses.each_key do |resource_klass|
+        missed_resource_ids[resource_klass] ||= []
 
         serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
         context_json = resource_klass.attribute_caching_context(context).to_json
@@ -47,7 +61,13 @@ module JSONAPI
             )
           )
         else
-          missed_resource_ids[resource_klass] = @resource_klasses[resource_klass].keys
+          @resource_klasses[resource_klass].keys.each do |k|
+            if @resource_klasses[resource_klass][k][:resource].nil?
+              missed_resource_ids[resource_klass] << k
+            else
+              register_resource(resource_klass, @resource_klasses[resource_klass][k][:resource])
+            end
+          end
         end
       end
 
@@ -60,7 +80,6 @@ module JSONAPI
         found_resources = {}
       end
 
-
       # Step Three collect the results and collect hit/miss stats
       stats = {}
       found_resources.each do |resource_klass, resources|
@@ -72,7 +91,6 @@ module JSONAPI
             stats[resource_klass][:misses] += 1
 
             # Collect misses
-            missed_resource_ids[resource_klass] ||= []
             missed_resource_ids[resource_klass].push(id)
           else
             stats[resource_klass][:hits] ||= 0
@@ -89,14 +107,15 @@ module JSONAPI
 
       # Step Four find any of the missing resources and join them into the result
       missed_resource_ids.each_pair do |resource_klass, ids|
-        find_opts = {context: context, fields: find_options[:fields]}
+        next if ids.empty?
+
+        find_opts = {context: context, fields: options[:fields]}
         found_resources = resource_klass.find_to_populate_by_keys(ids, find_opts)
 
         found_resources.each do |resource|
           relationship_data = @resource_klasses[resource_klass][resource.id][:relationships]
 
           if resource_klass.caching?
-
             serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
             context_json = resource_klass.attribute_caching_context(context).to_json
             context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
@@ -148,8 +167,8 @@ module JSONAPI
       end
     end
 
-    def flatten_resource_id_tree(resource_id_tree, flattened_tree = {})
-      resource_id_tree.fragments.each_pair do |resource_rid, fragment|
+    def flatten_resource_tree(resource_tree, flattened_tree = {})
+      resource_tree.fragments.each_pair do |resource_rid, fragment|
 
         resource_klass = resource_rid.resource_klass
         id = resource_rid.id
@@ -157,17 +176,18 @@ module JSONAPI
         flattened_tree[resource_klass] ||= {}
 
         flattened_tree[resource_klass][id] ||= {primary: fragment.primary, relationships: {}}
-        flattened_tree[resource_klass][id][:cache_id] ||= fragment.cache
+        flattened_tree[resource_klass][id][:cache_id] ||= fragment.cache if fragment.cache
+        flattened_tree[resource_klass][id][:resource] ||= fragment.resource if fragment.resource
 
         fragment.related.try(:each_pair) do |relationship_name, related_rids|
-          flattened_tree[resource_klass][id][:relationships][relationship_name] ||= Set.new
+          flattened_tree[resource_klass][id][:relationships][relationship_name] ||= SortedSet.new
           flattened_tree[resource_klass][id][:relationships][relationship_name].merge(related_rids)
         end
       end
 
-      related_resource_id_trees = resource_id_tree.related_resource_id_trees
-      related_resource_id_trees.try(:each_value) do |related_resource_id_tree|
-        flatten_resource_id_tree(related_resource_id_tree, flattened_tree)
+      related_resource_trees = resource_tree.related_resource_trees
+      related_resource_trees.try(:each_value) do |related_resource_tree|
+        flatten_resource_tree(related_resource_tree, flattened_tree)
       end
 
       flattened_tree

data/lib/jsonapi/resource_tree.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module JSONAPI
+
+  # A tree structure representing the resource structure of the requested resource(s). This is an intermediate structure
+  # used to keep track of the resources, by identity, found at different included relationships. It will be flattened and
+  # the resource instances will be fetched from the cache or the record store.
+  class ResourceTree
+
+    attr_reader :fragments, :related_resource_trees
+
+    # Gets the related Resource Id Tree for a relationship, and creates it first if it does not exist
+    #
+    # @param relationship [JSONAPI::Relationship]
+    #
+    # @return [JSONAPI::RelatedResourceTree] the new or existing resource id tree for the requested relationship
+    def get_related_resource_tree(relationship)
+      relationship_name = relationship.name.to_sym
+      @related_resource_trees[relationship_name] ||= RelatedResourceTree.new(relationship, self)
+    end
+
+    # Adds each Resource Fragment to the Resources hash
+    #
+    # @param fragments [Hash]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragments(fragments, include_related)
+      fragments.each_value do |fragment|
+        add_resource_fragment(fragment, include_related)
+      end
+    end
+
+    # Adds a Resource Fragment to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      init_included_relationships(fragment, include_related)
+
+      @fragments[fragment.identity] = fragment
+    end
+
+    # Adds each Resource to the fragments hash
+    #
+    # @param resource [Hash]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resources(resources, include_related)
+      resources.each do |resource|
+        add_resource_fragment(JSONAPI::ResourceFragment.new(resource.identity, resource: resource), include_related)
+      end
+    end
+
+    # Adds a Resource to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource(resource, include_related)
+      add_resource_fragment(JSONAPI::ResourceFragment.new(resource.identity, resource: resource), include_related)
+    end
+
+    private
+
+    def init_included_relationships(fragment, include_related)
+      include_related && include_related.each_key do |relationship_name|
+        fragment.initialize_related(relationship_name)
+      end
+    end
+
+    def load_included(resource_klass, source_resource_tree, include_related, options)
+       include_related.try(:each_key) do |key|
+        relationship = resource_klass._relationship(key)
+        relationship_name = relationship.name.to_sym
+
+        find_related_resource_options = options.except(:filters, :sort_criteria, :paginator)
+        find_related_resource_options[:sort_criteria] = relationship.resource_klass.default_sort
+        find_related_resource_options[:cache] = resource_klass.caching?
+
+        related_fragments = resource_klass.find_included_fragments(source_resource_tree.fragments.values,
+                                                                   relationship,
+                                                                   find_related_resource_options)
+
+        related_resource_tree = source_resource_tree.get_related_resource_tree(relationship)
+        related_resource_tree.add_resource_fragments(related_fragments, include_related[key][:include_related])
+
+        # Now recursively get the related resources for the currently found resources
+        load_included(relationship.resource_klass,
+                      related_resource_tree,
+                      include_related[relationship_name][:include_related],
+                      options)
+      end
+    end
+  end
+
+  class PrimaryResourceTree < ResourceTree
+
+    # Creates a PrimaryResourceTree with no resources and no related ResourceTrees
+    def initialize(fragments: nil, resources: nil, resource: nil, include_related: nil, options: nil)
+      @fragments ||= {}
+      @related_resource_trees ||= {}
+      if fragments || resources || resource
+        if fragments
+          add_resource_fragments(fragments, include_related)
+        end
+
+        if resources
+          add_resources(resources, include_related)
+        end
+
+        if resource
+          add_resource(resource, include_related)
+        end
+
+        complete_includes!(include_related, options)
+      end
+    end
+
+    # Adds a Resource Fragment to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      fragment.primary = true
+      super(fragment, include_related)
+    end
+
+    def complete_includes!(include_related, options)
+      # ToDo: can we skip if more than one resource_klass found?
+      resource_klasses = Set.new
+      @fragments.each_key { |identity| resource_klasses << identity.resource_klass }
+
+      resource_klasses.each { |resource_klass| load_included(resource_klass, self, include_related, options) }
+
+      self
+    end
+  end
+
+  class RelatedResourceTree < ResourceTree
+
+    attr_reader :parent_relationship, :source_resource_tree
+
+    # Creates a RelatedResourceTree with no resources and no related ResourceTrees. A connection to the parent
+    # ResourceTree is maintained.
+    #
+    # @param parent_relationship [JSONAPI::Relationship]
+    # @param source_resource_tree [JSONAPI::ResourceTree]
+    #
+    # @return [JSONAPI::RelatedResourceTree] the new or existing resource id tree for the requested relationship
+    def initialize(parent_relationship, source_resource_tree)
+      @fragments ||= {}
+      @related_resource_trees ||= {}
+
+      @parent_relationship = parent_relationship
+      @parent_relationship_name = parent_relationship.name.to_sym
+      @source_resource_tree = source_resource_tree
+    end
+
+    # Adds a Resource Fragment to the fragments hash
+    #
+    # @param fragment [JSONAPI::ResourceFragment]
+    # @param include_related [Hash]
+    #
+    # @return [null]
+    def add_resource_fragment(fragment, include_related)
+      init_included_relationships(fragment, include_related)
+
+      fragment.related_from.each do |rid|
+        @source_resource_tree.fragments[rid].add_related_identity(parent_relationship.name, fragment.identity)
+      end
+
+      if @fragments[fragment.identity]
+        @fragments[fragment.identity].related_from.merge(fragment.related_from)
+        fragment.related.each_pair do |relationship_name, rids|
+          if rids
+            @fragments[fragment.identity].merge_related_identities(relationship_name, rids)
+          end
+        end
+      else
+        @fragments[fragment.identity] = fragment
+      end
+    end
+  end
+end

data/lib/jsonapi/resources/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Resources
     class Railtie < Rails::Railtie
@@ -6,4 +8,4 @@ module JSONAPI
       end
     end
   end
-end
+end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module JSONAPI
   module Resources
-    VERSION = '0.10.6'
+    VERSION = '0.11.0.beta2'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class ResponseDocument
     attr_reader :serialized_results
@@ -17,7 +19,7 @@ module JSONAPI
     end
 
     def has_errors?
-      @error_results.length > 0 || @global_errors.length > 0
+      @error_results.length.positive? || @global_errors.length.positive?
     end
 
     def add_result(result, operation)
@@ -117,7 +119,7 @@ module JSONAPI
 
         result.pagination_params.each_pair do |link_name, params|
           if result.is_a?(JSONAPI::RelatedResourcesSetOperationResult)
-            relationship = result.source_resource.class._relationships[result._type.to_sym]
+            relationship = result.source_resource.class._relationship(result._type)
             unless relationship.exclude_link?(link_name)
               link = serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
             end

data/lib/jsonapi/routing_ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionDispatch
   module Routing
     class Mapper
@@ -222,7 +224,7 @@ module ActionDispatch
           options = relationship.extract_options!.dup
 
           relationship_name = relationship.first
-          relationship = source._relationships[relationship_name]
+          relationship = source._relationship(relationship_name)
 
           relationship._routed = true
 
@@ -246,7 +248,7 @@ module ActionDispatch
           options = relationship.extract_options!.dup
 
           relationship_name = relationship.first
-          relationship = source._relationships[relationship_name]
+          relationship = source._relationship(relationship_name)
 
           relationship._routed = true
 

data/lib/jsonapi/simple_resource.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'jsonapi/callbacks'
+require 'jsonapi/configuration'
+
+module JSONAPI
+  class SimpleResource
+    include ResourceCommon
+    root_resource
+    abstract
+    immutable
+  end
+end

data/lib/jsonapi-resources.rb

@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 require 'jsonapi/resources/railtie'
 require 'jsonapi/naive_cache'
 require 'jsonapi/compiled_json'
-require 'jsonapi/basic_resource'
-require 'jsonapi/active_relation_resource'
+require 'jsonapi/active_relation_retrieval'
+require 'jsonapi/active_relation_retrieval_v09'
+require 'jsonapi/active_relation_retrieval_v10'
+require 'jsonapi/resource_common'
 require 'jsonapi/resource'
+require 'jsonapi/simple_resource'
 require 'jsonapi/cached_response_fragment'
 require 'jsonapi/response_document'
 require 'jsonapi/acts_as_resource_controller'
@@ -25,7 +30,7 @@ require 'jsonapi/resource_serializer'
 require 'jsonapi/exceptions'
 require 'jsonapi/error'
 require 'jsonapi/error_codes'
-require 'jsonapi/request_parser'
+require 'jsonapi/request'
 require 'jsonapi/processor'
 require 'jsonapi/relationship'
 require 'jsonapi/include_directives'
@@ -35,9 +40,10 @@ require 'jsonapi/callbacks'
 require 'jsonapi/link_builder'
 require 'jsonapi/active_relation/adapters/join_left_active_record_adapter'
 require 'jsonapi/active_relation/join_manager'
+require 'jsonapi/active_relation/join_manager_v10'
 require 'jsonapi/resource_identity'
 require 'jsonapi/resource_fragment'
-require 'jsonapi/resource_id_tree'
+require 'jsonapi/resource_tree'
 require 'jsonapi/resource_set'
 require 'jsonapi/path'
 require 'jsonapi/path_segment'

data/lib/tasks/check_upgrade.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rake'
 require 'jsonapi-resources'
 
@@ -7,7 +9,7 @@ namespace :jsonapi do
     task :check_upgrade => :environment do
       Rails.application.eager_load!
 
-      resource_klasses = ObjectSpace.each_object(Class).select { |klass| klass < JSONAPI::Resource}
+      resource_klasses = ObjectSpace.each_object(Class).select { |klass| klass.include?(JSONAPI::ResourceCommon)}
 
       puts "Checking #{resource_klasses.count} resources"
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.10.6
+  version: 0.11.0.beta2
 platform: ruby
 authors:
 - Dan Gebhardt
 - Larry Gebhardt
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-07 00:00:00.000000000 Z
+date: 2023-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -129,34 +129,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  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
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -171,6 +185,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorted_set
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A resource-centric approach to implementing the controllers, routes,
   and serializers needed to support the JSON API spec.
 email:
@@ -192,9 +220,11 @@ files:
 - lib/jsonapi-resources.rb
 - lib/jsonapi/active_relation/adapters/join_left_active_record_adapter.rb
 - lib/jsonapi/active_relation/join_manager.rb
-- lib/jsonapi/active_relation_resource.rb
+- lib/jsonapi/active_relation/join_manager_v10.rb
+- lib/jsonapi/active_relation_retrieval.rb
+- lib/jsonapi/active_relation_retrieval_v09.rb
+- lib/jsonapi/active_relation_retrieval_v10.rb
 - lib/jsonapi/acts_as_resource_controller.rb
-- lib/jsonapi/basic_resource.rb
 - lib/jsonapi/cached_response_fragment.rb
 - lib/jsonapi/callbacks.rb
 - lib/jsonapi/compiled_json.rb
@@ -214,25 +244,27 @@ files:
 - lib/jsonapi/path_segment.rb
 - lib/jsonapi/processor.rb
 - lib/jsonapi/relationship.rb
-- lib/jsonapi/request_parser.rb
+- lib/jsonapi/request.rb
 - lib/jsonapi/resource.rb
+- lib/jsonapi/resource_common.rb
 - lib/jsonapi/resource_controller.rb
 - lib/jsonapi/resource_controller_metal.rb
 - lib/jsonapi/resource_fragment.rb
-- lib/jsonapi/resource_id_tree.rb
 - lib/jsonapi/resource_identity.rb
 - lib/jsonapi/resource_serializer.rb
 - lib/jsonapi/resource_set.rb
+- lib/jsonapi/resource_tree.rb
 - lib/jsonapi/resources/railtie.rb
 - lib/jsonapi/resources/version.rb
 - lib/jsonapi/response_document.rb
 - lib/jsonapi/routing_ext.rb
+- lib/jsonapi/simple_resource.rb
 - lib/tasks/check_upgrade.rake
 homepage: https://github.com/cerebris/jsonapi-resources
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -243,12 +275,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.6
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Easily support JSON API in Rails.
 test_files: []