graphiti 1.2.31 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c8a84a85ead11c3f8cf69f4e1fb060ea7e9ce6f470b31181214c5f62aa6f847
-  data.tar.gz: 52b0574208041cff9168e04e9e0946bbaa856c6dc22b1ea3f425673faffbffd5
+  metadata.gz: cbdb96a78aeac1f48bcea53a3b068638456e703b17fccf68d2f3813270db4bd8
+  data.tar.gz: c1dab2eff065e8ba70193cac81c6c5c44c57f81f9074082887ed7b52f2bcb000
 SHA512:
-  metadata.gz: 0ea059b18be0333f2193d024758de5c4a10a0f8f4e4c71d402a1b43e4d3b2f6a3fb9f426d21facf586406178d1e92398ade8f62c3c272adfdbb057623510ee54
-  data.tar.gz: 4fb47cd7b6a9397af3660bf1996cdc6f1a33d89d21f2bc67645189665093b0268e46776d1d5871374f7198e9549f15655e5cfc8535ce1a800b6fa4be17462f66
+  metadata.gz: 1a860a2d6cc8bfc494207ddd6bac1643c58ba09148fdf85b07c9198840728ace0f752fefb94bafa6599a97eb5ccfa6408544b08312aca5c6e01d77c874141821
+  data.tar.gz: 4a821372147d76d03a6d3e4dc5dce6ca205464d852892484567f725355459b0d5477418340ed9d53831a0062218e7b9daaf3560a0951c2decd8fd177a499954b

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,8 @@ Features:
 
 Fixes:
 - [282] Support model names including "Resource"
+- [313](https://github.com/graphiti-api/graphiti/pull/313) Sort remote resources in schema generation
+- [374](https://github.com/graphiti-api/graphiti/pull/374) Trim leading spaces from error messages
 
 ## 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/abstract.rb

@@ -244,14 +244,15 @@ module Graphiti
       # @param scope The scope object we are chaining
       # @param [Integer] current_page The current page number
       # @param [Integer] per_page The number of results per page
+      # @param [Integer] offset The offset to start from
       # @return the scope
       #
       # @example ActiveRecord default
       #   # via kaminari gem
-      #   def paginate(scope, current_page, per_page)
+      #   def paginate(scope, current_page, per_page, offset)
       #     scope.page(current_page).per(per_page)
       #   end
-      def paginate(scope, current_page, per_page)
+      def paginate(scope, current_page, per_page, offset)
         raise "you must override #paginate in an adapter subclass"
       end
 

data/lib/graphiti/adapters/active_record.rb

@@ -184,8 +184,11 @@ module Graphiti
       end
 
       # (see Adapters::Abstract#paginate)
-      def paginate(scope, current_page, per_page)
-        scope.page(current_page).per(per_page)
+      def paginate(scope, current_page, per_page, offset)
+        scope = scope.page(current_page) if current_page
+        scope = scope.per(per_page) if per_page
+        scope = scope.padding(offset) if offset
+        scope
       end
 
       # (see Adapters::Abstract#count)
@@ -240,7 +243,8 @@ module Graphiti
           children.each do |child|
             if association_type == :many_to_many &&
                 [:create, :update].include?(Graphiti.context[:namespace]) &&
-                !parent.send(association_name).exists?(child.id)
+                !parent.send(association_name).exists?(child.id) &&
+                child.errors.blank?
               parent.send(association_name) << child
             else
               target = association.instance_variable_get(:@target)

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/null.rb

@@ -178,7 +178,7 @@ module Graphiti
       end
 
       # (see Adapters::Abstract#paginate)
-      def paginate(scope, current_page, per_page)
+      def paginate(scope, current_page, per_page, offset)
         scope
       end
 

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,13 +11,24 @@ 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
-          links[:next] = pagination_link(current_page + 1) unless current_page == last_page
+          links[:prev] = pagination_link(current_page - 1) if has_previous_page?
+          links[:next] = pagination_link(current_page + 1) if has_next_page?
         end.select { |k, v| !v.nil? }
       end
 
+      def has_next_page?
+        current_page != last_page && last_page.present?
+      end
+
+      def has_previous_page?
+        current_page != 1 ||
+          !!pagination_params.try(:[], :page).try(:[], :after) ||
+          !!pagination_params.try(:[], :page).try(:[], :offset)
+      end
+
       private
 
       def pagination_params
@@ -29,13 +40,14 @@ module Graphiti
 
         uri = URI(@proxy.resource.endpoint[:url].to_s)
 
+        page_params = {
+          number: page,
+          size: page_size
+        }
+        page_params[:offset] = offset if offset
+
         # Overwrite the pagination query params with the desired page
-        uri.query = pagination_params.merge({
-          page: {
-            number: page,
-            size: page_size
-          }
-        }).to_query
+        uri.query = pagination_params.merge(page: page_params).to_query
         uri.to_s
       end
 
@@ -45,8 +57,11 @@ module Graphiti
         elsif page_size == 0 || item_count == 0
           return nil
         end
-        @last_page = (item_count / page_size)
-        @last_page += 1 if item_count % page_size > 0
+
+        count = item_count
+        count = item_count - offset if offset
+        @last_page = (count / page_size)
+        @last_page += 1 if count % page_size > 0
         @last_page
       end
 
@@ -81,6 +96,14 @@ module Graphiti
         @current_page ||= (page_param[:number] || 1).to_i
       end
 
+      def offset
+        @offset ||= begin
+          if (value = page_param[:offset])
+            value.to_i
+          end
+        end
+      end
+
       def page_size
         @page_size ||= (page_param[:size] ||
                         @proxy.resource.default_page_size ||

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
@@ -10,7 +35,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           The adapter #{@adapter.class} does not implement method '#{@method}', which was requested for attribute '#{@attribute}'. Add this method to your adapter to support this filter operator.
         MSG
       end
@@ -24,7 +49,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@parent_resource_class} sideload :#{@name} - #{@message}
         MSG
       end
@@ -53,7 +78,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@resource_class}: Tried to pass block to .#{@method_name}, which only accepts a method name.
         MSG
       end
@@ -65,7 +90,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@resource_class}: Tried to perform write operation. Writes are not supported for remote resources - hit the endpoint directly.
         MSG
       end
@@ -80,7 +105,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@resource.class}: Tried to filter #{@filter_name.inspect} on operator #{@operator.inspect}, but not supported! Supported operators are #{@supported}.
         MSG
       end
@@ -93,7 +118,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@sideload.parent_resource.class.name}: tried to sideload #{@sideload.name.inspect}, but more than one #{@sideload.parent_resource.model.name} was passed!
 
           This is because you marked the sideload #{@sideload.name.inspect} with single: true
@@ -114,7 +139,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@resource.class.name}: tried to sort on attribute #{@attribute.inspect}, but passed #{@direction.inspect} when only #{@allowlist.inspect} is supported.
         MSG
       end
@@ -127,7 +152,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@resource_class.name}: called .on_extra_attribute #{@name.inspect}, but extra attribute #{@name.inspect} does not exist!
         MSG
       end
@@ -148,7 +173,7 @@ module Graphiti
         else
           "value #{@value.inspect}"
         end
-        msg = <<-MSG
+        msg = <<~MSG
           #{@resource.class.name}: tried to filter on #{@filter.keys[0].inspect}, but passed invalid #{value_string}.
         MSG
         msg << "\nAllowlist: #{allow.inspect}" if allow
@@ -165,7 +190,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@resource_class.name} You declared an attribute or filter of type "#{@enum_type}" without providing a list of permitted values, which is required.
 
           When declaring an attribute:
@@ -189,7 +214,7 @@ module Graphiti
       end
 
       def message
-        <<-MSG
+        <<~MSG
           #{@resource_class.name}: Cannot link to sideload #{@sideload.name.inspect}!
 
           Make sure the endpoint "#{@sideload.resource.endpoint[:full_path]}" exists with action #{@action.inspect}, or customize the endpoint for #{@sideload.resource.class.name}.
@@ -708,6 +733,12 @@ module Graphiti
       end
     end
 
+    class UnsupportedBeforeCursor < Base
+      def message
+        "Passing in page[before] and page[number] is not supported. Please create an issue if you need it!"
+      end
+    end
+
     class InvalidInclude < Base
       def initialize(resource, relationship)
         @resource = resource
@@ -791,5 +822,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,55 +1,228 @@
 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?(:_cursor)
+          hash[:_cursor] = cursor
+        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?
+      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)
+      if @graphql
+        add_page_info(hash, serializers, top_level_key, options)
       end
+
+      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.each_with_index.map do |s, index|
+          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
+
+    # NB - this is only for top-level right now
+    # The casing here is GQL-specific, we can update later if needed.
+    def add_page_info(hash, serializers, top_level_key, options)
+      if (fields = options[:fields].try(:[], :page_info))
+        info = {}
+
+        if fields.include?(:has_next_page)
+          info[:hasNextPage] = options[:proxy].pagination.has_next_page?
+        end
+
+        if fields.include?(:has_previous_page)
+          info[:hasPreviousPage] = options[:proxy].pagination.has_previous_page?
+        end
+
+        if fields.include?(:start_cursor)
+          info[:startCursor] = serializers.first.try(:cursor)
+        end
+
+        if fields.include?(:end_cursor)
+          info[:endCursor] = serializers.last.try(:cursor)
         end
+
+        hash[top_level_key][:pageInfo] = info
       end
     end
   end