graphiti 1.2.31 → 1.2.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c8a84a85ead11c3f8cf69f4e1fb060ea7e9ce6f470b31181214c5f62aa6f847
-  data.tar.gz: 52b0574208041cff9168e04e9e0946bbaa856c6dc22b1ea3f425673faffbffd5
+  metadata.gz: 9ec84a0ed1957831fa1ae6bec24a6470d5bb16189681e096b5d59a468b95b49a
+  data.tar.gz: 145633f22cad8f867ce295337a0b3bc5adfc45da6695b481abb092d0f7b17ed8
 SHA512:
-  metadata.gz: 0ea059b18be0333f2193d024758de5c4a10a0f8f4e4c71d402a1b43e4d3b2f6a3fb9f426d21facf586406178d1e92398ade8f62c3c272adfdbb057623510ee54
-  data.tar.gz: 4fb47cd7b6a9397af3660bf1996cdc6f1a33d89d21f2bc67645189665093b0268e46776d1d5871374f7198e9549f15655e5cfc8535ce1a800b6fa4be17462f66
+  metadata.gz: a841e2eceebba1e495608ec2037a1c7deffa408fc7e408756a6edbfed0cfaded42d82abf55899724ec201a427a6f8226bbe554142739ff1067133d9d499835bd
+  data.tar.gz: 3e6b741c6942c8b5ae89b08c7d5fdc6eb71b4c1b82794788207813bc914f0f245c43f196d603e2478c7dba61145403c507e1d7937028f8e217e71144beb2c128

data/CHANGELOG.md

@@ -10,6 +10,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/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,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,7 +142,15 @@ 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)
           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/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)
@@ -144,6 +146,7 @@ module Graphiti
           if (@abstract_class = val)
             self.serializer = nil
             self.type = nil
+            self.graphql_entrypoint = nil
           end
         end
 

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/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

@@ -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
 

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/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.32"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.31
+  version: 1.2.32
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-02 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable