graphiti 1.2.27 → 1.2.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb8f1e8668da2d5d53c211b2f999a5109bf968815f1a700be6d5ee29537afc21
-  data.tar.gz: c60dd4731e33f6b495b82575989dc72376697ec21bbcbb01ce23021c61dbc26b
+  metadata.gz: 9ec84a0ed1957831fa1ae6bec24a6470d5bb16189681e096b5d59a468b95b49a
+  data.tar.gz: 145633f22cad8f867ce295337a0b3bc5adfc45da6695b481abb092d0f7b17ed8
 SHA512:
-  metadata.gz: ecd5b910c32aff8592b16406fb8cf12e3d8d00585e671900966c594e475ea9a4d7b620d7d7ff52d35aad9190563fc29f5ce0e1014d886ee35ed46b72e1791ca8
-  data.tar.gz: e1273d26d0571ae89f0405933888ac17b10083cfe250da9cb7d7118a511efe381cc03176ec9f78e30e5157d2ec2588883c6d113a22a84a0d326e9ccf02b016dd
+  metadata.gz: a841e2eceebba1e495608ec2037a1c7deffa408fc7e408756a6edbfed0cfaded42d82abf55899724ec201a427a6f8226bbe554142739ff1067133d9d499835bd
+  data.tar.gz: 3e6b741c6942c8b5ae89b08c7d5fdc6eb71b4c1b82794788207813bc914f0f245c43f196d603e2478c7dba61145403c507e1d7937028f8e217e71144beb2c128

data/.travis.yml

@@ -19,7 +19,13 @@ env:
   - COMMAND="standardrb --no-fix --format progress"
   - COMMAND=rspec
   - COMMAND=rspec APPRAISAL_INITIALIZED=true
-matrix:
+jobs:
+  allow_failures:
+  - rvm: ruby-head
+  include:
+    - env: COMMAND=rspec
+      gemfile: Gemfile
+      rvm: ruby-head
   exclude:
     # Don't run the appraisal version of the specs for the base gemfile
     - env: COMMAND=rspec APPRAISAL_INITIALIZED=true

data/CHANGELOG.md

@@ -8,6 +8,10 @@ Features:
 - [157](https://github.com/graphiti-api/graphiti/pull/157) Using attribute option schema: false.
   This option is default true and is not effected by only and except options. (@zeisler)
 
+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
 
 Features:

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/graphiti.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = "~> 2.3"
+  spec.required_ruby_version = [">= 2.3", "< 3.1"]
 
   spec.add_dependency "jsonapi-serializable", "~> 0.3.0"
   spec.add_dependency "jsonapi-renderer", "~> 0.2", ">= 0.2.2"

data/lib/graphiti/adapters/abstract.rb

@@ -1,6 +1,9 @@
 module Graphiti
   module Adapters
     class Abstract
+      require "graphiti/adapters/persistence/associations.rb"
+      include Graphiti::Adapters::Persistence::Associations
+
       attr_reader :resource
 
       def initialize(resource)
@@ -400,6 +403,13 @@ module Graphiti
         raise "you must override #destroy in an adapter subclass"
       end
 
+      def close
+      end
+
+      def persistence_attributes(persistance, attributes)
+        attributes
+      end
+
       def self.numerical_operators
         [:eq, :not_eq, :gt, :gte, :lt, :lte].freeze
       end

data/lib/graphiti/adapters/active_record.rb

@@ -191,7 +191,7 @@ module Graphiti
       # (see Adapters::Abstract#count)
       def count(scope, attr)
         if attr.to_sym == :total
-          scope.distinct.count
+          scope.distinct.count(:all)
         else
           scope.distinct.count(attr)
         end
@@ -297,6 +297,10 @@ module Graphiti
         model_instance
       end
 
+      def close
+        ::ActiveRecord::Base.clear_active_connections!
+      end
+
       private
 
       def column_for(scope, name)

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

@@ -0,0 +1,80 @@
+module Graphiti
+  module Adapters
+    module Persistence
+      module Associations
+        def process_belongs_to(persistence, attributes)
+          parents = [].tap do |processed|
+            persistence.iterate(only: [:polymorphic_belongs_to, :belongs_to]) do |x|
+              begin
+                id = x.dig(:attributes, :id)
+                x[:object] = x[:resource]
+                  .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
+                processed << x
+              rescue Graphiti::Errors::RecordNotFound
+                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
+
+          update_foreign_key_for_parents(parents, attributes)
+          parents
+        end
+
+        def process_has_many(persistence, caller_model)
+          [].tap do |processed|
+            persistence.iterate(except: [:polymorphic_belongs_to, :belongs_to]) do |x|
+              update_foreign_key(caller_model, x[:attributes], x)
+
+              x[:object] = x[:resource]
+                .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], caller_model, x[:foreign_key])
+
+              processed << x
+            end
+          end
+        end
+
+        def update_foreign_key_for_parents(parents, attributes)
+          parents.each do |x|
+            update_foreign_key(x[:object], attributes, x)
+          end
+        end
+
+        # The child's attributes should be modified to nil-out the
+        # foreign_key when the parent is being destroyed or disassociated
+        #
+        # This is not the case for HABTM, whose "foreign key" is a join table
+        def update_foreign_key(parent_object, attrs, x)
+          return if x[:sideload].type == :many_to_many
+
+          if [:destroy, :disassociate].include?(x[:meta][:method])
+            if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
+              attrs[:"#{x[:sideload].polymorphic_as}_type"] = nil
+            end
+            attrs[x[:foreign_key]] = nil
+            update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
+          else
+            if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
+              attrs[:"#{x[:sideload].polymorphic_as}_type"] = parent_object.class.name
+            end
+            attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
+            update_foreign_type(attrs, x) if x[:is_polymorphic]
+          end
+        end
+
+        def update_foreign_type(attrs, x, null: false)
+          grouping_field = x[:sideload].parent.grouper.field_name
+          attrs[grouping_field] = null ? nil : x[:sideload].group_name
+        end
+      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

@@ -6,11 +6,12 @@ module Graphiti
       end
 
       def links?
-        @proxy.query.pagination_links?
+        @proxy.query.pagination_links? && @proxy.data.present?
       end
 
       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
@@ -53,7 +54,7 @@ module Graphiti
       def item_count
         begin
           return @item_count if @item_count
-          @item_count = @proxy.resource.stat(:total, :count).call(@proxy.scope.unpaginated_object, :total)
+          @item_count = item_count_from_proxy || item_count_from_stats
           unless @item_count.is_a?(Numeric)
             raise TypeError, "#{@proxy.resource}.stat(:total, :count) returned an invalid value #{@item_count}"
           end
@@ -68,6 +69,15 @@ module Graphiti
         @item_count
       end
 
+      def item_count_from_proxy
+        @proxy.stats.dig(:total, :count)
+      end
+
+      def item_count_from_stats
+        stats = Stats::Payload.new(@proxy.resource, @proxy.query, @proxy.scope.unpaginated_object, @proxy.data)
+        stats.calculate_stat(:total, @proxy.resource.stat(:total, :count))
+      end
+
       def current_page
         @current_page ||= (page_param[:number] || 1).to_i
       end

data/lib/graphiti/errors.rb

@@ -2,6 +2,32 @@ 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
+      extend ActiveModel::Naming
+      attr_accessor :id, :errors, :pointer
+
+      def initialize(id, pointer)
+        @id = id
+        @pointer = pointer
+        @errors = ActiveModel::Errors.new(self)
+      end
+
+      def self.human_attribute_name(attr, options = {})
+        attr
+      end
+    end
+
     class AdapterNotImplemented < Base
       def initialize(adapter, attribute, method)
         @adapter = adapter

data/lib/graphiti/hash_renderer.rb

@@ -1,39 +1,138 @@
 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)
         }
-        rels = @_relationships.select { |k, v| !!include[k] }
+
+        # 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.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?
+            attrs[name.to_sym] = if serializers.is_a?(Array)
+              serializers.map do |rr|
+                rr.to_hash(fields: fields, include: nested_include, graphql: graphql, name_chain: name_chain)
+              end
+            elsif serializers.nil?
+              if @resource.class.respond_to?(:sideload)
+                if @resource.class.sideload(k).type.to_s.include?("_many")
+                  []
+                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])
           end
         end
 
-        hash[:id] = jsonapi_id
+        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.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)
+      opts[:graphql] = @graphql
       to_hash(serializers, opts).tap do |hash|
         hash.merge!(options.slice(:meta)) unless options[:meta].empty?
       end
@@ -43,12 +142,20 @@ module Graphiti
 
     def to_hash(serializers, opts)
       {}.tap do |hash|
-        hash[:data] = if serializers.is_a?(Array)
+        top_level_key = :data
+        if @graphql
+          top_level_key = @resource.graphql_entrypoint
+          unless serializers.is_a?(Array)
+            top_level_key = top_level_key.to_s.singularize.to_sym
+          end
+        end
+
+        hash[top_level_key] = if serializers.is_a?(Array)
           serializers.map do |s|
-            s.to_hash(opts)
+            s.to_hash(**opts)
           end
         else
-          serializers.to_hash(opts)
+          serializers.to_hash(**opts)
         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/validator.rb

@@ -51,7 +51,7 @@ module Graphiti
           relationships: relationships
         }
 
-        Graphiti::Util::RelationshipPayload.iterate(opts) do |x|
+        Graphiti::Util::RelationshipPayload.iterate(**opts) do |x|
           sideload_def = x[:sideload]
 
           unless sideload_def.writable?

data/lib/graphiti/resource/configuration.rb

@@ -83,7 +83,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 +98,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)
@@ -129,7 +131,7 @@ module Graphiti
         def get_attr(name, flag, opts = {})
           defaults = {request: false}
           opts = defaults.merge(opts)
-          new.get_attr(name, flag, opts)
+          new.get_attr(name, flag, **opts)
         end
 
         def abstract_class?
@@ -144,19 +146,20 @@ module Graphiti
           if (@abstract_class = val)
             self.serializer = nil
             self.type = nil
+            self.graphql_entrypoint = nil
           end
         end
 
         def infer_type
           if name.present?
-            name.demodulize.gsub("Resource", "").underscore.pluralize.to_sym
+            name.demodulize.sub(/.*\KResource/, "").underscore.pluralize.to_sym
           else
             :undefined_jsonapi_type
           end
         end
 
         def infer_model
-          name&.gsub("Resource", "")&.safe_constantize
+          name&.sub(/.*\KResource/, "")&.safe_constantize
         end
 
         # @api private
@@ -247,7 +250,7 @@ module Graphiti
 
       def get_attr!(name, flag, options = {})
         options[:raise_error] = true
-        get_attr(name, flag, options)
+        get_attr(name, flag, **options)
       end
 
       def get_attr(name, flag, request: false, raise_error: false)

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,6 +90,7 @@ 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),
@@ -108,7 +110,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
@@ -202,6 +204,9 @@ module Graphiti
               config[:guard] = true
             end
           end
+          if filter[:required] # one-off filter, not attribute
+            config[:required] = true
+          end
           f[name] = config
         end
       end
@@ -214,6 +219,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/scope.rb

@@ -45,9 +45,7 @@ module Graphiti
         resolve_sideload = -> {
           Graphiti.context = graphiti_context
           sideload.resolve(results, q, parent_resource)
-          if concurrent && defined?(ActiveRecord)
-            ActiveRecord::Base.clear_active_connections!
-          end
+          @resource.adapter.close if concurrent
         }
         if concurrent
           promises << Concurrent::Promise.execute(&resolve_sideload)

data/lib/graphiti/serializer.rb

@@ -12,29 +12,46 @@ 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
 
-    def as_jsonapi(*)
-      super.tap do |hash|
+    def as_jsonapi(kwargs = {})
+      super(**kwargs).tap do |hash|
         strip_relationships!(hash) if strip_relationships?
         add_links!(hash)
       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

@@ -26,8 +26,8 @@ module Graphiti
       @foreign_key = opts[:foreign_key]
       @type = opts[:type]
       @base_scope = opts[:base_scope]
-      @readable = evaluate_flag(opts[:readable])
-      @writable = evaluate_flag(opts[:writable])
+      @readable = opts[:readable]
+      @writable = opts[:writable]
       @as = opts[:as]
       @link = opts[:link]
       @single = opts[:single]
@@ -209,7 +209,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
 
@@ -426,6 +428,7 @@ module Graphiti
       Util::Class.namespace_for(klass)
     end
 
+    # TODO: call this at runtime to support procs
     def evaluate_flag(flag)
       return false if flag.blank?
 

data/lib/graphiti/sideload/many_to_many.rb

@@ -36,9 +36,12 @@ class Graphiti::Sideload::ManyToMany < Graphiti::Sideload::HasMany
     self_ref = self
     fk_type = parent_resource_class.attributes[:id][:type]
     fk_type = :hash if polymorphic?
-    resource_class.filter inverse_filter, fk_type do
-      eq do |scope, value|
-        self_ref.belongs_to_many_filter(scope, value)
+    # Do not recreate if filter already exists
+    unless resource_class.config[:filters].has_key?(inverse_filter.to_sym)
+      resource_class.filter inverse_filter, fk_type do
+        eq do |scope, value|
+          self_ref.belongs_to_many_filter(scope, value)
+        end
       end
     end
   end

data/lib/graphiti/stats/payload.rb

@@ -31,16 +31,19 @@ module Graphiti
             stats[name] = {}
 
             each_calculation(name, calculation) do |calc, function|
-              args = [@scope, name]
-              args << @resource.context if function.arity >= 3
-              args << @data if function.arity == 4
-
-              stats[name][calc] = function.call(*args)
+              stats[name][calc] = calculate_stat(name, function)
             end
           end
         end
       end
 
+      def calculate_stat(name, function)
+        args = [@scope, name]
+        args << @resource.context if function.arity >= 3
+        args << @data if function.arity == 4
+        function.call(*args)
+      end
+
       private
 
       def each_calculation(name, calculations)

data/lib/graphiti/util/attribute_check.rb

@@ -44,7 +44,7 @@ module Graphiti
           Graphiti::Errors::UnknownAttribute
 
         if raise_error?(opts[:exists])
-          raise error_class.new(resource, name, flag, opts)
+          raise error_class.new(resource, name, flag, **opts)
         else
           false
         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/persistence.rb

@@ -14,6 +14,7 @@ class Graphiti::Util::Persistence
     @relationships = relationships
     @caller_model = caller_model
     @foreign_key = foreign_key
+    @adapter = @resource.adapter
 
     # Find the correct child resource for a given jsonapi type
     if (meta_type = @meta[:type].try(:to_sym))
@@ -43,18 +44,16 @@ class Graphiti::Util::Persistence
   #
   # @return a model instance
   def run
-    parents = process_belongs_to(@relationships)
-    update_foreign_key_for_parents(parents)
+    attributes = @adapter.persistence_attributes(self, @attributes)
 
-    persisted = persist_object(@meta[:method], @attributes)
+    parents = @adapter.process_belongs_to(self, attributes)
+    persisted = persist_object(@meta[:method], attributes)
     @resource.decorate_record(persisted)
     assign_temp_id(persisted, @meta[:temp_id])
 
     associate_parents(persisted, parents)
 
-    children = process_has_many(@relationships, persisted) { |x|
-      update_foreign_key(persisted, x[:attributes], x)
-    }
+    children = @adapter.process_has_many(self, persisted)
 
     associate_children(persisted, children) unless @meta[:method] == :destroy
 
@@ -69,43 +68,21 @@ class Graphiti::Util::Persistence
     persisted
   end
 
-  private
-
-  def add_hook(prc, lifecycle_event)
-    ::Graphiti::Util::TransactionHooksRecorder.add(prc, lifecycle_event)
-  end
-
-  # The child's attributes should be modified to nil-out the
-  # foreign_key when the parent is being destroyed or disassociated
-  #
-  # This is not the case for HABTM, whose "foreign key" is a join table
-  def update_foreign_key(parent_object, attrs, x)
-    return if x[:sideload].type == :many_to_many
+  def iterate(only: [], except: [])
+    opts = {
+      resource: @resource,
+      relationships: @relationships
+    }.merge(only: only, except: except)
 
-    if [:destroy, :disassociate].include?(x[:meta][:method])
-      if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
-        attrs[:"#{x[:sideload].polymorphic_as}_type"] = nil
-      end
-      attrs[x[:foreign_key]] = nil
-      update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
-    else
-      if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
-        attrs[:"#{x[:sideload].polymorphic_as}_type"] = parent_object.class.name
-      end
-      attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
-      update_foreign_type(attrs, x) if x[:is_polymorphic]
+    Graphiti::Util::RelationshipPayload.iterate(**opts) do |x|
+      yield x
     end
   end
 
-  def update_foreign_type(attrs, x, null: false)
-    grouping_field = x[:sideload].parent.grouper.field_name
-    attrs[grouping_field] = null ? nil : x[:sideload].group_name
-  end
+  private
 
-  def update_foreign_key_for_parents(parents)
-    parents.each do |x|
-      update_foreign_key(x[:object], @attributes, x)
-    end
+  def add_hook(prc, lifecycle_event)
+    ::Graphiti::Util::TransactionHooksRecorder.add(prc, lifecycle_event)
   end
 
   def associate_parents(object, parents)
@@ -161,35 +138,6 @@ class Graphiti::Util::Persistence
     end
   end
 
-  def process_has_many(relationships, caller_model)
-    [].tap do |processed|
-      iterate(except: [:polymorphic_belongs_to, :belongs_to]) do |x|
-        yield x
-
-        x[:object] = x[:resource]
-          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], caller_model, x[:foreign_key])
-
-        processed << x
-      end
-    end
-  end
-
-  def process_belongs_to(relationships)
-    [].tap do |processed|
-      iterate(only: [:polymorphic_belongs_to, :belongs_to]) do |x|
-        begin
-          id = x.dig(:attributes, :id)
-          x[:object] = x[:resource]
-            .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)
-        end
-      end
-    end
-  end
-
   def post_process(caller_model, processed)
     groups = processed.group_by { |x| x[:meta][:method] }
     groups.each_pair do |method, group|
@@ -205,17 +153,6 @@ class Graphiti::Util::Persistence
     object.instance_variable_set(:@_jsonapi_temp_id, temp_id)
   end
 
-  def iterate(only: [], except: [])
-    opts = {
-      resource: @resource,
-      relationships: @relationships
-    }.merge(only: only, except: except)
-
-    Graphiti::Util::RelationshipPayload.iterate(opts) do |x|
-      yield x
-    end
-  end
-
   def metadata
     {
       method: @meta[:method],

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
@@ -55,14 +65,22 @@ module Graphiti
       def guard
         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)
-          else
+          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.27"
+  VERSION = "1.2.32"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.27
+  version: 1.2.32
 platform: ruby
 authors:
 - Lee Richmond
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-03 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -204,7 +204,7 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.0.beta.4
-description: 
+description:
 email:
 - richmolj@gmail.com
 executables:
@@ -266,6 +266,7 @@ files:
 - lib/graphiti/adapters/active_record/many_to_many_sideload.rb
 - lib/graphiti/adapters/graphiti_api.rb
 - lib/graphiti/adapters/null.rb
+- lib/graphiti/adapters/persistence/associations.rb
 - lib/graphiti/cli.rb
 - lib/graphiti/configuration.rb
 - lib/graphiti/context.rb
@@ -341,15 +342,18 @@ homepage: https://github.com/graphiti-api/graphiti
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -357,7 +361,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Easily build jsonapi.org-compatible APIs
 test_files: []