graphiti 1.2.31 → 1.2.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c8a84a85ead11c3f8cf69f4e1fb060ea7e9ce6f470b31181214c5f62aa6f847
-  data.tar.gz: 52b0574208041cff9168e04e9e0946bbaa856c6dc22b1ea3f425673faffbffd5
+  metadata.gz: 2b7630aef39d3ce4584f53710a5cbe8617addc0a0ea042077c41562accb1c5cf
+  data.tar.gz: aad06cd10d1f2604432303990cf92d7b885333d15ccd733a5d0bbab062346872
 SHA512:
-  metadata.gz: 0ea059b18be0333f2193d024758de5c4a10a0f8f4e4c71d402a1b43e4d3b2f6a3fb9f426d21facf586406178d1e92398ade8f62c3c272adfdbb057623510ee54
-  data.tar.gz: 4fb47cd7b6a9397af3660bf1996cdc6f1a33d89d21f2bc67645189665093b0268e46776d1d5871374f7198e9549f15655e5cfc8535ce1a800b6fa4be17462f66
+  metadata.gz: 063c97d7d4c719c1cbff7a8028b54a0d862e763bda69a8bae12cbe4a2d5201183b6d516936e9339faf3d35307a1375cf28859253e5fd3c6d1b5824b306fe0d2a
+  data.tar.gz: 07dc6893d86bbdfbe676b15707edae40601159d1bb7239b58004280e3c9e5d29c313a9bcc525a2fe7e9582f6191972b8095c0d4a5873a72f15cb5589c9879841

data/CHANGELOG.md

@@ -1,6 +1,7 @@
 ## Unreleased
 
 Features:
+- [329](https://github.com/graphiti-api/graphiti/pull/329) Propagate `extra_fields` to related resource links.
 - [242](https://github.com/graphiti-api/graphiti/pull/242) Bump `jsonapi-renderer` to `~0.2.2` now that (https://github.com/jsonapi-rb/jsonapi-renderer/pull/36) is fixed.
 - [158](https://github.com/graphiti-api/graphiti/pull/158) Filters options `allow_nil: true`
   Option can be set at the resource level `Resource.filters_accept_nil_by_default = true`. 
@@ -10,6 +11,7 @@ Features:
 
 Fixes:
 - [282] Support model names including "Resource"
+- [313](https://github.com/graphiti-api/graphiti/pull/313) Sort remote resources in schema generation
 
 ## 1.1.0
 

data/deprecated_generators/graphiti/generator_mixin.rb

@@ -12,6 +12,7 @@ module Graphiti
     def api_namespace
       @api_namespace ||= begin
         ns = graphiti_config["namespace"]
+        ns.delete_suffix("/")
 
         if ns.blank?
           ns = prompt \

data/lib/graphiti.rb

@@ -6,6 +6,7 @@ require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/hash/conversions" # to_xml
 require "active_support/concern"
 require "active_support/time"
+require "active_support/deprecation"
 
 require "dry-types"
 require "graphiti_errors"
@@ -141,6 +142,7 @@ require "graphiti/scoping/sort"
 require "graphiti/scoping/paginate"
 require "graphiti/scoping/extra_attributes"
 require "graphiti/scoping/filterable"
+require "graphiti/scoping/filter_group_validator"
 require "graphiti/scoping/default_filter"
 require "graphiti/scoping/filter"
 require "graphiti/stats/dsl"

data/lib/graphiti/adapters/graphiti_api.rb

@@ -34,7 +34,7 @@ module Graphiti
 
       def build_url(scope)
         url = resource.remote_url
-        params = scope[:params].merge(scope.except(:params))
+        params = scope[:params].merge(scope.except(:params, :foreign_key))
         params[:page] ||= {}
         params[:page][:size] ||= 999
         params = CGI.unescape(params.to_query)

data/lib/graphiti/adapters/persistence/associations.rb

@@ -11,8 +11,16 @@ module Graphiti
                   .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
                 processed << x
               rescue Graphiti::Errors::RecordNotFound
-                path = "relationships/#{x.dig(:meta, :jsonapi_type)}"
-                raise Graphiti::Errors::RecordNotFound.new(x[:sideload].name, id, path)
+                if Graphiti.config.raise_on_missing_sidepost
+                  path = "relationships/#{x.dig(:meta, :jsonapi_type)}"
+                  raise Graphiti::Errors::RecordNotFound.new(x[:sideload].name, id, path)
+                else
+                  pointer = "data/relationships/#{x.dig(:meta, :jsonapi_type)}"
+                  object = Graphiti::Errors::NullRelation.new(id.to_s, pointer)
+                  object.errors.add(:base, :not_found, message: "could not be found")
+                  x[:object] = object
+                  processed << x
+                end
               end
             end
           end

data/lib/graphiti/configuration.rb

@@ -14,6 +14,7 @@ module Graphiti
     attr_accessor :pagination_links_on_demand
     attr_accessor :pagination_links
     attr_accessor :typecast_reads
+    attr_accessor :raise_on_missing_sidepost
 
     attr_reader :debug, :debug_models
 
@@ -29,6 +30,7 @@ module Graphiti
       @pagination_links_on_demand = false
       @pagination_links = false
       @typecast_reads = true
+      @raise_on_missing_sidepost = true
       self.debug = ENV.fetch("GRAPHITI_DEBUG", true)
       self.debug_models = ENV.fetch("GRAPHITI_DEBUG_MODELS", false)
 
@@ -43,7 +45,7 @@ module Graphiti
         end
 
         if (logger = ::Rails.logger)
-          self.debug = logger.level.zero? && debug
+          self.debug = logger.debug? && debug
           Graphiti.logger = logger
         end
       end

data/lib/graphiti/delegates/pagination.rb

@@ -11,6 +11,7 @@ module Graphiti
 
       def links
         @links ||= {}.tap do |links|
+          links[:self] = pagination_link(current_page)
           links[:first] = pagination_link(1)
           links[:last] = pagination_link(last_page)
           links[:prev] = pagination_link(current_page - 1) unless current_page == 1

data/lib/graphiti/errors.rb

@@ -2,6 +2,31 @@ module Graphiti
   module Errors
     class Base < StandardError; end
 
+    class UnreadableAttribute < Base
+      def initialize(resource_class, name)
+        @resource_class = resource_class
+        @name = name
+      end
+
+      def message
+        "#{@resource_class}: Requested field #{@name}, but not authorized to read it"
+      end
+    end
+
+    class NullRelation
+      attr_accessor :id, :errors, :pointer
+
+      def initialize(id, pointer)
+        @id = id
+        @pointer = pointer
+        @errors = Graphiti::Util::SimpleErrors.new(self)
+      end
+
+      def self.human_attribute_name(attr, options = {})
+        attr
+      end
+    end
+
     class AdapterNotImplemented < Base
       def initialize(adapter, attribute, method)
         @adapter = adapter
@@ -791,5 +816,34 @@ module Graphiti
 
     class ConflictRequest < InvalidRequest
     end
+
+    class FilterGroupInvalidRequirement < Base
+      def initialize(resource, valid_required_values)
+        @resource = resource
+        @valid_required_values = valid_required_values
+      end
+
+      def message
+        <<-MSG.gsub(/\s+/, " ").strip
+          The filter group required: value on resource #{@resource.class} must be one of the following:
+          #{@valid_required_values.join(", ")}
+        MSG
+      end
+    end
+
+    class FilterGroupMissingRequiredFilters < Base
+      def initialize(resource, filter_names, required)
+        @resource = resource
+        @filter_names = filter_names
+        @required_label = required == :all ? "All" : "One"
+      end
+
+      def message
+        <<-MSG.gsub(/\s+/, " ").strip
+          #{@required_label} of the following filters must be provided on resource #{@resource.type}:
+          #{@filter_names.join(", ")}
+        MSG
+      end
+    end
   end
 end

data/lib/graphiti/extensions/extra_attribute.rb

@@ -46,9 +46,9 @@ module Graphiti
               next false unless instance_exec(&options[:if])
             end
 
-            @extra_fields &&
-              @extra_fields[@_type] &&
-              @extra_fields[@_type].include?(name)
+            next false unless @extra_fields
+
+            @extra_fields[@_type]&.include?(name) || @extra_fields[@resource&.type]&.include?(name)
           }
 
           attribute name, if: allow_field, &blk

data/lib/graphiti/hash_renderer.rb

@@ -1,54 +1,193 @@
 module Graphiti
   module SerializableHash
-    def to_hash(fields: nil, include: {})
+    def to_hash(fields: nil, include: {}, name_chain: [], graphql: false)
       {}.tap do |hash|
-        fields_list = fields[jsonapi_type] if fields
+        if fields
+          fields_list = nil
+
+          # Dot syntax wins over jsonapi type
+          if name_chain.length > 0
+            fields_list = fields[name_chain.join(".").to_sym]
+          end
+
+          if fields_list.nil?
+            fields_list = fields[jsonapi_type]
+          end
+        end
+
+        # polymorphic resources - merge the PARENT type
+        if polymorphic_subclass?
+          if fields[@resource.type]
+            fields_list ||= []
+            fields_list |= fields[@resource.type]
+          end
+
+          if fields[jsonapi_type]
+            fields_list ||= []
+            fields_list |= fields[jsonapi_type]
+          end
+        end
+
         attrs = requested_attributes(fields_list).each_with_object({}) { |(k, v), h|
-          h[k] = instance_eval(&v)
+          name = graphql ? k.to_s.camelize(:lower).to_sym : k
+          h[name] = instance_eval(&v)
+        }
+
+        # The main logic here is just !!include[k]
+        # But we also have special on__<type>--<name> includes
+        # Where we only include when matching the polymorphic type
+        rels = @_relationships.select { |k, v|
+          if include[k]
+            true
+          else
+            included = false
+            include.keys.each do |key|
+              split = key.to_s.split(/^on__/)
+              if split.length > 1
+                requested_type, key = split[1].split("--")
+                if requested_type.to_sym == jsonapi_type
+                  included = k == key.to_sym
+                  break
+                end
+              end
+            end
+            included
+          end
         }
-        rels = @_relationships.select { |k, v| !!include[k] }
+
         rels.each_with_object({}) do |(k, v), h|
+          nested_include = include[k]
+
+          # This logic only fires if it's a special on__<type>--<name> include
+          unless include.has_key?(k)
+            include.keys.each do |include_key|
+              if k == include_key.to_s.split("--")[1].to_sym
+                nested_include = include[include_key]
+                break
+              end
+            end
+          end
+
           serializers = v.send(:resources)
-          attrs[k] = if serializers.is_a?(Array)
-            serializers.map do |rr| # use private method to avoid array casting
-              rr.to_hash(fields: fields, include: include[k])
+          name = graphql ? k.to_s.camelize(:lower) : k
+          name_chain = name_chain.dup
+          name_chain << k unless name_chain.last == k
+
+          unless remote_resource? && serializers.nil?
+            payload = if serializers.is_a?(Array)
+              data = serializers.map { |rr|
+                rr.to_hash(fields: fields, include: nested_include, graphql: graphql, name_chain: name_chain)
+              }
+              graphql ? {nodes: data} : data
+            elsif serializers.nil?
+              if @resource.class.respond_to?(:sideload)
+                if @resource.class.sideload(k).type.to_s.include?("_many")
+                  graphql ? {nodes: []} : []
+                end
+              end
+            else
+              serializers.to_hash(fields: fields, include: nested_include, graphql: graphql, name_chain: name_chain)
             end
-          elsif serializers.nil?
-            nil
-          else
-            serializers.to_hash(fields: fields, include: include[k])
+
+            attrs[name.to_sym] = payload
+          end
+        end
+
+        if !graphql || (fields_list || []).include?(:id)
+          hash[:id] = jsonapi_id
+        end
+
+        if (fields_list || []).include?(:_type)
+          hash[:_type] = jsonapi_type.to_s
+        end
+
+        if (fields_list || []).include?(:__typename)
+          resource_class = @resource.class
+          if polymorphic_subclass?
+            resource_class = @resource.class.resource_for_type(jsonapi_type)
           end
+          hash[:__typename] = ::Graphiti::Util::Class
+            .graphql_type_name(resource_class.name)
         end
 
-        hash[:id] = jsonapi_id
         hash.merge!(attrs) if attrs.any?
       end
     end
+
+    def polymorphic_subclass?
+      !remote_resource? &&
+        @resource.polymorphic? &&
+        @resource.type != jsonapi_type
+    end
+
+    # See hack in util/remote_serializer.rb
+    def remote_resource?
+      @resource == 1
+    end
   end
 
   class HashRenderer
-    def initialize(resource)
+    def initialize(resource, graphql: false)
       @resource = resource
+      @graphql = graphql
     end
 
     def render(options)
       serializers = options[:data]
       opts = options.slice(:fields, :include)
-      to_hash(serializers, opts).tap do |hash|
-        hash.merge!(options.slice(:meta)) unless options[:meta].empty?
-      end
+      opts[:graphql] = @graphql
+      top_level_key = get_top_level_key(@resource, serializers.is_a?(Array))
+
+      hash = {top_level_key => {}}
+      nodes = get_nodes(serializers, opts)
+      add_nodes(hash, top_level_key, options, nodes, @graphql)
+      add_stats(hash, top_level_key, options, @graphql)
+      hash
     end
 
     private
 
-    def to_hash(serializers, opts)
-      {}.tap do |hash|
-        hash[:data] = if serializers.is_a?(Array)
-          serializers.map do |s|
-            s.to_hash(**opts)
+    def get_top_level_key(resource, is_many)
+      key = :data
+
+      if @graphql
+        key = @resource.graphql_entrypoint
+        key = key.to_s.singularize.to_sym unless is_many
+      end
+
+      key
+    end
+
+    def get_nodes(serializers, opts)
+      if serializers.is_a?(Array)
+        serializers.map do |s|
+          s.to_hash(**opts)
+        end
+      else
+        serializers.to_hash(**opts)
+      end
+    end
+
+    def add_nodes(hash, top_level_key, opts, nodes, graphql)
+      payload = nodes
+      if graphql && nodes.is_a?(Array)
+        payload = {nodes: nodes}
+      end
+
+      # Don't render nodes if we only requested stats
+      unless graphql && opts[:fields].values == [[:stats]]
+        hash[top_level_key] = payload
+      end
+    end
+
+    def add_stats(hash, top_level_key, options, graphql)
+      if options[:meta] && !options[:meta].empty?
+        if @graphql
+          if (stats = options[:meta][:stats])
+            hash[top_level_key][:stats] = stats
           end
         else
-          serializers.to_hash(**opts)
+          hash.merge!(options.slice(:meta))
         end
       end
     end

data/lib/graphiti/query.rb

@@ -96,7 +96,18 @@ module Graphiti
               sl_resource = resource_for_sideload(sideload)
               query_parents = parents + [self]
               sub_hash = sub_hash[:include] if sub_hash.key?(:include)
-              hash[key] = Query.new(sl_resource, @params, key, sub_hash, query_parents, :all)
+
+              # NB: To handle on__<type>--<name>
+              # A) relationship_name == :positions
+              # B) key == on__employees.positions
+              # This way A) ensures sideloads are resolved
+              # And B) ensures nested filters, sorts etc still work
+              relationship_name = sideload ? sideload.name : key
+              hash[relationship_name] = Query.new sl_resource,
+                @params,
+                key,
+                sub_hash,
+                query_parents, :all
             else
               handle_missing_sideload(key)
             end

data/lib/graphiti/renderer.rb

@@ -17,8 +17,20 @@ module Graphiti
       render(self.class.jsonapi_renderer).to_json
     end
 
+    def as_graphql
+      render(self.class.graphql_renderer(@proxy))
+    end
+
+    def to_graphql
+      as_graphql.to_json
+    end
+
     def to_json
-      render(self.class.hash_renderer(@proxy)).to_json
+      as_json.to_json
+    end
+
+    def as_json
+      render(self.class.hash_renderer(@proxy))
     end
 
     def to_xml
@@ -35,6 +47,11 @@ module Graphiti
       JSONAPI::Serializable::Renderer.new(implementation)
     end
 
+    def self.graphql_renderer(proxy)
+      implementation = Graphiti::HashRenderer.new(proxy.resource, graphql: true)
+      JSONAPI::Serializable::Renderer.new(implementation)
+    end
+
     private
 
     def render(renderer)

data/lib/graphiti/request_validators/update_validator.rb

@@ -26,17 +26,17 @@ module Graphiti
           [:data, :type],
           [:data, :id]
         ].each do |required_attr|
-          attribute_mismatch(required_attr) unless @raw_params.dig(*required_attr)
+          attribute_mismatch(required_attr) unless @params.dig(*required_attr)
         end
         errors.blank?
       end
 
       def payload_matches_endpoint?
-        unless @raw_params.dig(:data, :id) == @raw_params.dig(:filter, :id)
+        unless @params.dig(:data, :id) == @params.dig(:filter, :id)
           attribute_mismatch([:data, :id])
         end
 
-        meta_type = @raw_params.dig(:data, :type)
+        meta_type = @params.dig(:data, :type)
 
         # NOTE: calling #to_s and comparing 2 strings is slower than
         # calling #to_sym and comparing 2 symbols. But pre ruby-2.2

data/lib/graphiti/request_validators/validator.rb

@@ -5,21 +5,31 @@ module Graphiti
 
       def initialize(root_resource, raw_params, action)
         @root_resource = root_resource
-        @raw_params = raw_params
+        @params = normalized_params(raw_params)
         @errors = Graphiti::Util::SimpleErrors.new(raw_params)
         @action = action
       end
 
       def validate
+        # Right now, all requests - even reads - go through the validator
+        # In the future these should have their own validation logic, but
+        # for now we can just bypass
+        return true unless @params.has_key?(:data)
+
         resource = @root_resource
-        if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
-          if @root_resource.type != meta_type && @root_resource.polymorphic?
-            resource = @root_resource.class.resource_for_type(meta_type).new
+
+        if @params[:data].has_key?(:type)
+          if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
+            if @root_resource.type != meta_type && @root_resource.polymorphic?
+              resource = @root_resource.class.resource_for_type(meta_type).new
+            end
           end
-        end
 
-        typecast_attributes(resource, deserialized_payload.attributes, deserialized_payload.meta[:payload_path])
-        process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+          typecast_attributes(resource, deserialized_payload.attributes, deserialized_payload.meta[:payload_path])
+          process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+        else
+          errors.add(:"data.type", :missing)
+        end
 
         errors.blank?
       end
@@ -33,14 +43,7 @@ module Graphiti
       end
 
       def deserialized_payload
-        @deserialized_payload ||= begin
-                                    payload = normalized_params
-                                    if payload[:data] && payload[:data][:type]
-                                      Graphiti::Deserializer.new(payload)
-                                    else
-                                      Graphiti::Deserializer.new({})
-                                    end
-                                  end
+        @deserialized_payload ||= Graphiti::Deserializer.new(@params)
       end
 
       private
@@ -86,8 +89,8 @@ module Graphiti
         end
       end
 
-      def normalized_params
-        normalized = @raw_params
+      def normalized_params(raw_params)
+        normalized = raw_params
         if normalized.respond_to?(:to_unsafe_h)
           normalized = normalized.to_unsafe_h.deep_symbolize_keys
         end

data/lib/graphiti/resource/configuration.rb

@@ -28,6 +28,14 @@ module Graphiti
           end
         end
 
+        def graphql_entrypoint=(val)
+          if val
+            super(val.to_s.camelize(:lower).to_sym)
+          else
+            super
+          end
+        end
+
         # The .stat call stores a proc based on adapter
         # So if we assign a new adapter, reconfigure
         def adapter=(val)
@@ -83,7 +91,8 @@ module Graphiti
           :relationships_readable_by_default,
           :relationships_writable_by_default,
           :filters_accept_nil_by_default,
-          :filters_deny_empty_by_default
+          :filters_deny_empty_by_default,
+          :graphql_entrypoint
 
         class << self
           prepend Overrides
@@ -97,6 +106,7 @@ module Graphiti
           # re-assigning causes a new Class.new
           klass.serializer = (klass.serializer || klass.infer_serializer_superclass)
           klass.type ||= klass.infer_type
+          klass.graphql_entrypoint = klass.type.to_s.pluralize.to_sym
           default(klass, :attributes_readable_by_default, true)
           default(klass, :attributes_writable_by_default, true)
           default(klass, :attributes_sortable_by_default, true)
@@ -144,6 +154,7 @@ module Graphiti
           if (@abstract_class = val)
             self.serializer = nil
             self.type = nil
+            self.graphql_entrypoint = nil
           end
         end
 
@@ -188,6 +199,7 @@ module Graphiti
           @config ||=
             {
               filters: {},
+              grouped_filters: {},
               default_filters: {},
               stats: {},
               sort_all: nil,
@@ -224,6 +236,10 @@ module Graphiti
           config[:filters]
         end
 
+        def grouped_filters
+          config[:grouped_filters]
+        end
+
         def sorts
           config[:sorts]
         end
@@ -262,6 +278,10 @@ module Graphiti
         self.class.filters
       end
 
+      def grouped_filters
+        self.class.grouped_filters
+      end
+
       def sort_all
         self.class.sort_all
       end

data/lib/graphiti/resource/dsl.rb

@@ -44,6 +44,17 @@ module Graphiti
           end
         end
 
+        def filter_group(filter_names, *args)
+          opts = args.extract_options!
+
+          Scoping::FilterGroupValidator.raise_unless_filter_group_requirement_valid!(self, opts[:required])
+
+          config[:grouped_filters] = {
+            names: filter_names,
+            required: opts[:required]
+          }
+        end
+
         def sort_all(&blk)
           if block_given?
             config[:_sort_all] = blk

data/lib/graphiti/resource/interface.rb

@@ -46,7 +46,7 @@ module Graphiti
         private
 
         def validate!(params)
-          return unless validate_endpoints?
+          return if Graphiti.context[:graphql] || !validate_endpoints?
 
           if context&.respond_to?(:request)
             path = context.request.env["PATH_INFO"]

data/lib/graphiti/resource/polymorphism.rb

@@ -42,9 +42,14 @@ module Graphiti
         end
 
         def sideload(name)
-          sl = super
+          if (split_on = name.to_s.split(/^on__/)).length > 1
+            on_type, name = split_on[1].split("--").map(&:to_sym)
+          end
+
+          sl = super(name)
           if !polymorphic_child? && sl.nil?
             children.each do |c|
+              next if on_type && c.type != on_type
               break if (sl = c.sideloads[name])
             end
           end

data/lib/graphiti/resource/remote.rb

@@ -31,7 +31,7 @@ module Graphiti
       end
 
       def before_resolve(scope, query)
-        scope[:params] = Util::RemoteParams.generate(self, query)
+        scope[:params] = Util::RemoteParams.generate(self, query, scope[:foreign_key])
         scope
       end
 

data/lib/graphiti/resource_proxy.rb

@@ -47,10 +47,22 @@ module Graphiti
       Renderer.new(self, options).to_json
     end
 
+    def as_json(options = {})
+      Renderer.new(self, options).as_json
+    end
+
     def to_xml(options = {})
       Renderer.new(self, options).to_xml
     end
 
+    def to_graphql(options = {})
+      Renderer.new(self, options).to_graphql
+    end
+
+    def as_graphql(options = {})
+      Renderer.new(self, options).as_graphql
+    end
+
     def data
       @data ||= begin
         records = @scope.resolve

data/lib/graphiti/schema.rb

@@ -7,6 +7,7 @@ module Graphiti
       ::Rails.application.eager_load! if defined?(::Rails)
       resources ||= Graphiti.resources.reject(&:abstract_class?)
       resources.reject! { |r| r.name.nil? }
+
       new(resources).generate
     end
 
@@ -25,7 +26,7 @@ module Graphiti
 
     def initialize(resources)
       @resources = resources.sort_by(&:name)
-      @remote_resources = resources.select(&:remote?)
+      @remote_resources = @resources.select(&:remote?)
       @local_resources = @resources - @remote_resources
     end
 
@@ -89,14 +90,20 @@ module Graphiti
         config = {
           name: r.name,
           type: r.type.to_s,
+          graphql_entrypoint: r.graphql_entrypoint.to_s,
           description: r.description,
           attributes: attributes(r),
           extra_attributes: extra_attributes(r),
           sorts: sorts(r),
           filters: filters(r),
-          relationships: relationships(r)
+          relationships: relationships(r),
+          stats: stats(r)
         }
 
+        if r.grouped_filters.any?
+          config[:filter_group] = r.grouped_filters
+        end
+
         if r.default_sort
           default_sort = r.default_sort.map { |s|
             {s.keys.first.to_s => s.values.first.to_s}
@@ -108,7 +115,7 @@ module Graphiti
           config[:default_page_size] = r.default_page_size
         end
 
-        if r.polymorphic?
+        if r.polymorphic? && !r.polymorphic_child?
           config[:polymorphic] = true
           config[:children] = r.children.map(&:name)
         end
@@ -163,6 +170,14 @@ module Graphiti
       end
     end
 
+    def stats(resource)
+      {}.tap do |stats|
+        resource.stats.each_pair do |name, config|
+          stats[name] = config.calculations.keys
+        end
+      end
+    end
+
     def sorts(resource)
       {}.tap do |s|
         resource.sorts.each_pair do |name, sort|
@@ -202,11 +217,18 @@ module Graphiti
               config[:guard] = true
             end
           end
+          if filter[:required] # one-off filter, not attribute
+            config[:required] = true
+          end
           f[name] = config
         end
       end
     end
 
+    def filter_group(resource)
+      resource.config[:grouped_filters]
+    end
+
     def relationships(resource)
       {}.tap do |r|
         resource.sideloads.each_pair do |name, config|
@@ -214,6 +236,7 @@ module Graphiti
           if config.type == :polymorphic_belongs_to
             schema[:resources] = config.children.values
               .map(&:resource).map(&:class).map(&:name)
+            schema[:parent_resource] = config.parent_resource.class.name
           else
             schema[:resource] = config.resource.class.name
           end

data/lib/graphiti/schema_diff.rb

@@ -30,6 +30,8 @@ module Graphiti
           compare_extra_attributes(r, new_resource)
           compare_sorts(r, new_resource)
           compare_filters(r, new_resource)
+          compare_filter_group(r, new_resource)
+          compare_stats(r, new_resource)
           compare_relationships(r, new_resource)
         end
       end
@@ -204,6 +206,42 @@ module Graphiti
       end
     end
 
+    def compare_filter_group(old_resource, new_resource)
+      if new_resource[:filter_group]
+        if old_resource[:filter_group]
+          new_names = new_resource[:filter_group][:names]
+          old_names = old_resource[:filter_group][:names]
+          diff = new_names - old_names
+          if !diff.empty? && new_resource[:filter_group][:required] == :all
+            @errors << "#{old_resource[:name]}: all required filter group #{old_names.inspect} added #{"member".pluralize(diff.length)} #{diff.inspect}."
+          end
+
+          old_required = old_resource[:filter_group][:required]
+          new_required = new_resource[:filter_group][:required]
+          if old_required == :any && new_required == :all
+            @errors << "#{old_resource[:name]}: filter group #{old_names.inspect} moved from required: :any to required: :all"
+          end
+        else
+          @errors << "#{old_resource[:name]}: filter group #{new_resource[:filter_group][:names].inspect} was added."
+        end
+      end
+    end
+
+    def compare_stats(old_resource, new_resource)
+      old_resource[:stats].each_pair do |name, old_calculations|
+        new_calculations = new_resource[:stats][name]
+        if new_calculations
+          old_calculations.each do |calc|
+            unless new_calculations.include?(calc)
+              @errors << "#{old_resource[:name]}: calculation #{calc.inspect} was removed from stat #{name.inspect}."
+            end
+          end
+        else
+          @errors << "#{old_resource[:name]}: stat #{name.inspect} was removed."
+        end
+      end
+    end
+
     def compare_endpoints
       @old[:endpoints].each_pair do |path, old_endpoint|
         unless (new_endpoint = @new[:endpoints][path])

data/lib/graphiti/scoping/filter.rb

@@ -3,6 +3,13 @@ module Graphiti
     include Scoping::Filterable
 
     def apply
+      unless @opts[:bypass_required_filters]
+        Graphiti::Scoping::FilterGroupValidator.new(
+          resource,
+          query_hash
+        ).raise_unless_filter_group_requirements_met!
+      end
+
       if missing_required_filters.any? && !@opts[:bypass_required_filters]
         raise Errors::RequiredFilter.new(resource, missing_required_filters)
       end

data/lib/graphiti/scoping/filter_group_validator.rb

@@ -0,0 +1,78 @@
+module Graphiti
+  class Scoping::FilterGroupValidator
+    VALID_REQUIRED_VALUES = %i[all any]
+
+    def self.raise_unless_filter_group_requirement_valid!(resource, requirement)
+      unless VALID_REQUIRED_VALUES.include?(requirement)
+        raise Errors::FilterGroupInvalidRequirement.new(
+          resource,
+          VALID_REQUIRED_VALUES
+        )
+      end
+
+      true
+    end
+
+    def initialize(resource, query_hash)
+      @resource = resource
+      @query_hash = query_hash
+    end
+
+    def raise_unless_filter_group_requirements_met!
+      return if grouped_filters.empty?
+
+      case filter_group_requirement
+      when :all
+        raise_unless_all_requirements_met!
+      when :any
+        raise_unless_any_requirements_met!
+      end
+
+      true
+    end
+
+    private
+
+    attr_reader :resource, :query_hash
+
+    def raise_unless_all_requirements_met!
+      met = filter_group_names.all? { |filter_name| filter_group_filter_param.key?(filter_name) }
+
+      unless met
+        raise Errors::FilterGroupMissingRequiredFilters.new(
+          resource,
+          filter_group_names,
+          filter_group_requirement
+        )
+      end
+    end
+
+    def raise_unless_any_requirements_met!
+      met = filter_group_names.any? { |filter_name| filter_group_filter_param.key?(filter_name) }
+
+      unless met
+        raise Errors::FilterGroupMissingRequiredFilters.new(
+          resource,
+          filter_group_names,
+          filter_group_requirement
+        )
+      end
+    end
+
+    def filter_group_names
+      grouped_filters.fetch(:names, [])
+    end
+
+    def filter_group_requirement
+      grouped_filters.fetch(:required, :invalid)
+    end
+
+    def grouped_filters
+      resource.grouped_filters
+    end
+
+    def filter_group_filter_param
+      query_hash.fetch(:filter, {})
+    end
+  end
+end

data/lib/graphiti/serializer.rb

@@ -12,13 +12,36 @@ module Graphiti
     # go through type checking/coercion
     class_attribute :attributes_applied_via_resource
     class_attribute :extra_attributes_applied_via_resource
+    class_attribute :relationship_condition_blocks
     self.attributes_applied_via_resource = []
     self.extra_attributes_applied_via_resource = []
+    # See #requested_relationships
+    self.relationship_condition_blocks ||= {}
 
     def self.inherited(klass)
       super
       klass.class_eval do
         extend JSONAPI::Serializable::Resource::ConditionalFields
+
+        # See #requested_relationships
+        def self.relationship(name, options = {}, &block)
+          super
+          field_condition_blocks.delete(name)
+          _register_condition(relationship_condition_blocks, name, options)
+        end
+
+        # NB - avoid clobbering includes when sparse fieldset
+        # https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
+        #
+        # We also override this method to ensure attributes and relationships
+        # have separate condition blocks. This way an attribute and
+        # relationship can have the same name, and the attribute can be
+        # conditional without affecting the relationship.
+        def requested_relationships(fields)
+          @_relationships.select do |k, _|
+            _conditionally_included?(self.class.relationship_condition_blocks, k)
+          end
+        end
       end
     end
 
@@ -29,12 +52,6 @@ module Graphiti
       end
     end
 
-    # Temporary fix until fixed upstream
-    # https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
-    def requested_relationships(fields)
-      @_relationships
-    end
-
     # Allow access to resource methods
     def method_missing(id, *args, &blk)
       if @resource.respond_to?(id, true)

data/lib/graphiti/sideload.rb

@@ -136,6 +136,14 @@ module Graphiti
       base_filter(parents)
     end
 
+    def link_extra_fields
+      extra_fields_name = [association_name, resource.type].find { |param|
+        context.params.dig(:extra_fields, param)
+      }
+
+      {resource.type => context.params.dig(:extra_fields, extra_fields_name)} if extra_fields_name
+    end
+
     # The parent resource is a remote,
     # AND the sideload is a remote to the same endpoint
     def shared_remote?
@@ -209,7 +217,9 @@ module Graphiti
       end
 
       with_error_handling(Errors::SideloadQueryBuildingError) do
-        proxy = resource.class._all(params, opts, base_scope)
+        scope = base_scope
+        scope[:foreign_key] = foreign_key if remote?
+        proxy = resource.class._all(params, opts, scope)
         pre_load_proc&.call(proxy, parents)
       end
 

data/lib/graphiti/util/class.rb

@@ -20,6 +20,12 @@ module Graphiti
         split = namespace.split("::")
         split[0, split.length - 1].join("::")
       end
+
+      def self.graphql_type_name(name)
+        name.gsub("Resource", "")
+          .gsub("::", "") # remove modules
+          .gsub(".", "__") # remove remote resource .
+      end
     end
   end
 end

data/lib/graphiti/util/link.rb

@@ -63,6 +63,10 @@ module Graphiti
             params[:filter] = @sideload.link_filter([@model])
           end
 
+          if (extra_fields = @sideload.link_extra_fields)
+            params[:extra_fields] ||= extra_fields
+          end
+
           @sideload.params_proc&.call(params, [@model], context)
         end
       end

data/lib/graphiti/util/remote_params.rb

@@ -2,13 +2,14 @@
 module Graphiti
   module Util
     class RemoteParams
-      def self.generate(resource, query)
-        new(resource, query).generate
+      def self.generate(resource, query, foreign_key)
+        new(resource, query, foreign_key).generate
       end
 
-      def initialize(resource, query)
+      def initialize(resource, query, foreign_key)
         @resource = resource
         @query = query
+        @foreign_key = foreign_key
         @sorts = []
         @filters = {}
         @fields = {}
@@ -97,7 +98,11 @@ module Graphiti
         return unless fields
 
         fields.each_pair do |type, attrs|
-          @fields[type] = attrs.join(",")
+          all_attrs = attrs
+          if @foreign_key
+            all_attrs |= [@foreign_key]
+          end
+          @fields[type] = all_attrs.join(",")
         end
       end
 

data/lib/graphiti/util/remote_serializer.rb

@@ -44,6 +44,7 @@ module Graphiti
           model.delete_field(:_relationships)
           # If this isn't set, Array(resources) will return []
           # This is important, because jsonapi-serializable makes this call
+          # To see the test failure, remote resource position > department
           model.instance_variable_set(:@__graphiti_resource, 1)
           model.instance_variable_set(:@__graphiti_serializer, serializer)
         end

data/lib/graphiti/util/serializer_attributes.rb

@@ -12,18 +12,20 @@ module Graphiti
       def apply
         return unless readable?
 
+        remove_guard if previously_guarded?
+
         if @name == :id
           @serializer.id(&proc)
         elsif @attr[:proc]
           @serializer.send(_method, @name, serializer_options, &proc)
         elsif @serializer.attribute_blocks[@name].nil?
           @serializer.send(_method, @name, serializer_options, &proc)
+        elsif @serializer.send(applied_method).include?(@name)
+          @serializer.field_condition_blocks[@name] = guard if guard?
         else
-          unless @serializer.send(applied_method).include?(@name)
-            inner = @serializer.attribute_blocks.delete(@name)
-            wrapped = wrap_proc(inner)
-            @serializer.send(_method, @name, serializer_options, &wrapped)
-          end
+          inner = @serializer.attribute_blocks.delete(@name)
+          wrapped = wrap_proc(inner)
+          @serializer.send(_method, @name, serializer_options, &wrapped)
         end
 
         existing = @serializer.send(applied_method)
@@ -32,6 +34,14 @@ module Graphiti
 
       private
 
+      def previously_guarded?
+        @serializer.field_condition_blocks[@name]
+      end
+
+      def remove_guard
+        @serializer.field_condition_blocks.delete(@name)
+      end
+
       def applied_method
         if extra?
           :extra_attributes_applied_via_resource
@@ -56,16 +66,21 @@ module Graphiti
         method_name = @attr[:readable]
         instance = @resource.new
         attribute = @name.to_s
+        resource_class = @resource
 
         -> {
           method = instance.method(method_name)
-          if method.arity.zero?
+          result = if method.arity.zero?
             instance.instance_eval(&method_name)
           elsif method.arity == 1
             instance.instance_exec(@object, &method)
           else
             instance.instance_exec(@object, attribute, &method)
           end
+          if Graphiti.context[:graphql] && !result
+            raise ::Graphiti::Errors::UnreadableAttribute.new(resource_class, attribute)
+          end
+          result
         }
       end
 

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.2.31"
+  VERSION = "1.2.36"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.31
+  version: 1.2.36
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-02 00:00:00.000000000 Z
+date: 2021-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -308,6 +308,7 @@ files:
 - lib/graphiti/scoping/default_filter.rb
 - lib/graphiti/scoping/extra_attributes.rb
 - lib/graphiti/scoping/filter.rb
+- lib/graphiti/scoping/filter_group_validator.rb
 - lib/graphiti/scoping/filterable.rb
 - lib/graphiti/scoping/paginate.rb
 - lib/graphiti/scoping/sort.rb