graphiti 1.2.16 → 1.3.9

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
@@ -143,8 +168,13 @@ module Graphiti
       def message
         allow = @filter.values[0][:allow]
         deny = @filter.values[0][:deny]
-        msg = <<-MSG
-          #{@resource.class.name}: tried to filter on #{@filter.keys[0].inspect}, but passed invalid value #{@value.inspect}.
+        value_string = if @value == "(empty)"
+          "empty value"
+        else
+          "value #{@value.inspect}"
+        end
+        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
         msg << "\nDenylist: #{deny.inspect}" if deny
@@ -160,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:
@@ -184,12 +214,12 @@ 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}.
 
-          If you do not wish to generate a link, pass link: false or set self.relationship_links_by_default = false.
+          If you do not wish to generate a link, pass link: false or set self.autolink = false.
         MSG
       end
     end
@@ -316,14 +346,14 @@ module Graphiti
             sortable: "sort on",
             filterable: "filter on",
             readable: "read",
-            writable: "write",
+            writable: "write"
           }[@flag]
         else
           {
             sortable: "add sort",
             filterable: "add filter",
             readable: "read",
-            writable: "write",
+            writable: "write"
           }[@flag]
         end
       end
@@ -361,6 +391,20 @@ module Graphiti
       end
     end
 
+    class UndefinedIDLookup < Base
+      def initialize(resource_class)
+        @resource_class = resource_class
+      end
+
+      def message
+        <<~MSG
+          Tried to resolve #{@resource_class} with an :id filter, but the filter was nil.
+          This can result in unscoping a query, which can cause incorrect values to be
+          returned which may or may not bypass standard access controls.
+        MSG
+      end
+    end
+
     class UnknownAttribute < AttributeError
       def message
         "#{super}, but could not find an attribute with that name."
@@ -689,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
@@ -722,6 +772,21 @@ module Graphiti
     end
 
     class RecordNotFound < Base
+      def initialize(resource = nil, id = nil, path = nil)
+        @resource = resource
+        @id = id
+        @path = path
+      end
+
+      def message
+        if !@resource.nil? && !@id.nil?
+          "The referenced resource '#{@resource}' with id '#{@id}' could not be found.".tap do |msg|
+            msg << " Referenced at '#{@path}'" unless @path.nil?
+          end
+        else
+          "Specified Record Not Found"
+        end
+      end
     end
 
     class RequiredFilter < Base
@@ -757,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

@@ -43,12 +43,12 @@ module Graphiti
         def extra_attribute(name, options = {}, &blk)
           allow_field = proc {
             if options[:if]
-              next false unless instance_eval(&options[:if])
+              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/extensions/temp_id.rb

@@ -13,7 +13,7 @@ module Graphiti
     # Common interface for jsonapi-rb extensions
     def as_jsonapi(*)
       super.tap do |hash|
-        if (temp_id = @object.instance_variable_get(:'@_jsonapi_temp_id'))
+        if (temp_id = @object.instance_variable_get(:@_jsonapi_temp_id))
           hash[:'temp-id'] = temp_id
         end
       end

data/lib/graphiti/filter_operators.rb

@@ -17,7 +17,6 @@ module Graphiti
         end
       end
 
-      # rubocop: disable Style/MethodMissingSuper
       def method_missing(name, *args, &blk)
         @procs[name] = blk
       end

data/lib/graphiti/hash_renderer.rb

@@ -1,55 +1,232 @@
 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
 
-        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?(:_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.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])
+            camelized = {}
+            stats.each_pair do |key, value|
+              camelized[key.to_s.camelize(:lower).to_sym] = value
+            end
+            hash[top_level_key][:stats] = camelized
           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