graphiti 1.2.16 → 1.3.9

data/lib/graphiti/query.rb

@@ -1,8 +1,8 @@
 module Graphiti
   class Query
-    attr_reader :resource, :association_name, :params
+    attr_reader :resource, :association_name, :params, :action
 
-    def initialize(resource, params, association_name = nil, nested_include = nil, parents = [])
+    def initialize(resource, params, association_name = nil, nested_include = nil, parents = [], action = nil)
       @resource = resource
       @association_name = association_name
       @params = params
@@ -11,6 +11,7 @@ module Graphiti
       @params = @params.deep_symbolize_keys
       @include_param = nested_include || @params[:include]
       @parents = parents
+      @action = parse_action(action)
     end
 
     def association?
@@ -31,7 +32,9 @@ module Graphiti
     end
 
     def pagination_links?
-      if Graphiti.config.pagination_links_on_demand
+      if action == :find
+        false
+      elsif Graphiti.config.pagination_links_on_demand
         [true, "true"].include?(@params[:pagination_links])
       else
         Graphiti.config.pagination_links
@@ -44,16 +47,19 @@ module Graphiti
 
     def hash
       @hash ||= {}.tap do |h|
-        h[:filter] = filters unless filters.empty?
-        h[:sort] = sorts unless sorts.empty?
-        h[:page] = pagination unless pagination.empty?
-        unless association?
-          h[:fields] = fields unless fields.empty?
-          h[:extra_fields] = extra_fields unless extra_fields.empty?
+        h[:filter] = filters
+        h[:sort] = sorts
+        h[:page] = pagination
+        if association?
+          resource_type = @resource.class.type
+          h[:extra_fields] = {resource_type => extra_fields[resource_type]} if extra_fields.key?(resource_type)
+        else
+          h[:fields] = fields
+          h[:extra_fields] = extra_fields
         end
-        h[:stats] = stats unless stats.empty?
-        h[:include] = sideload_hash unless sideload_hash.empty?
-      end
+        h[:stats] = stats
+        h[:include] = sideload_hash
+      end.reject { |_, value| value.empty? }
     end
 
     def zero_results?
@@ -63,11 +69,9 @@ module Graphiti
     end
 
     def sideload_hash
-      @sideload_hash = begin
-        {}.tap do |hash|
-          sideloads.each_pair do |key, value|
-            hash[key] = sideloads[key].hash
-          end
+      @sideload_hash = {}.tap do |hash|
+        sideloads.each_pair do |key, value|
+          hash[key] = sideloads[key].hash
         end
       end
     end
@@ -83,19 +87,28 @@ module Graphiti
     end
 
     def sideloads
-      @sideloads ||= begin
-        {}.tap do |hash|
-          include_hash.each_pair do |key, sub_hash|
-            sideload = @resource.class.sideload(key)
-
-            if sideload || @resource.remote?
-              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)
-            else
-              handle_missing_sideload(key)
-            end
+      @sideloads ||= {}.tap do |hash|
+        include_hash.each_pair do |key, sub_hash|
+          sideload = @resource.class.sideload(key)
+
+          if sideload || @resource.remote?
+            sl_resource = resource_for_sideload(sideload)
+            query_parents = parents + [self]
+            sub_hash = sub_hash[:include] if sub_hash.key?(:include)
+
+            # 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
         end
       end
@@ -120,27 +133,25 @@ module Graphiti
     end
 
     def filters
-      @filters ||= begin
-        {}.tap do |hash|
-          (@params[:filter] || {}).each_pair do |name, value|
-            name = name.to_sym
-
-            if legacy_nested?(name)
-              value.keys.each do |key|
-                filter_name = key.to_sym
-                filter_value = value[key]
-
-                if @resource.get_attr!(filter_name, :filterable, request: true)
-                  hash[filter_name] = filter_value
-                end
+      @filters ||= {}.tap do |hash|
+        (@params[:filter] || {}).each_pair do |name, value|
+          name = name.to_sym
+
+          if legacy_nested?(name)
+            value.keys.each do |key|
+              filter_name = key.to_sym
+              filter_value = value[key]
+
+              if @resource.get_attr!(filter_name, :filterable, request: true)
+                hash[filter_name] = filter_value
               end
-            elsif nested?(name)
-              name = name.to_s.split(".").last.to_sym
-              validate!(name, :filterable)
-              hash[name] = value
-            elsif top_level? && validate!(name, :filterable)
-              hash[name] = value
             end
+          elsif nested?(name)
+            name = name.to_s.split(".").last.to_sym
+            validate!(name, :filterable)
+            hash[name] = value
+          elsif top_level? && validate!(name, :filterable)
+            hash[name] = value
           end
         end
       end
@@ -169,18 +180,17 @@ module Graphiti
     end
 
     def pagination
-      @pagination ||= begin
-        {}.tap do |hash|
-          (@params[:page] || {}).each_pair do |name, value|
-            if legacy_nested?(name)
-              value.each_pair do |k, v|
-                hash[k.to_sym] = v.to_i
-              end
-            elsif nested?(name)
-              hash[name.to_s.split(".").last.to_sym] = value
-            elsif top_level? && [:number, :size].include?(name.to_sym)
-              hash[name.to_sym] = value.to_i
+      @pagination ||= {}.tap do |hash|
+        (@params[:page] || {}).each_pair do |name, value|
+          if legacy_nested?(name)
+            value.each_pair do |k, v|
+              hash[k.to_sym] = cast_page_param(k.to_sym, v)
             end
+          elsif nested?(name)
+            param_name = name.to_s.split(".").last.to_sym
+            hash[param_name] = cast_page_param(param_name, value)
+          elsif top_level? && Scoping::Paginate::PARAMS.include?(name.to_sym)
+            hash[name.to_sym] = cast_page_param(name.to_sym, value)
           end
         end
       end
@@ -203,15 +213,13 @@ module Graphiti
     end
 
     def stats
-      @stats ||= begin
-        {}.tap do |hash|
-          (@params[:stats] || {}).each_pair do |k, v|
-            if legacy_nested?(k)
-              raise NotImplementedError.new("Association statistics are not currently supported")
-            elsif top_level?
-              v = v.split(",") if v.is_a?(String)
-              hash[k.to_sym] = Array(v).flatten.map(&:to_sym)
-            end
+      @stats ||= {}.tap do |hash|
+        (@params[:stats] || {}).each_pair do |k, v|
+          if legacy_nested?(k)
+            raise NotImplementedError.new("Association statistics are not currently supported")
+          elsif top_level?
+            v = v.split(",") if v.is_a?(String)
+            hash[k.to_sym] = Array(v).flatten.map(&:to_sym)
           end
         end
       end
@@ -223,6 +231,18 @@ module Graphiti
 
     private
 
+    def cast_page_param(name, value)
+      if [:before, :after].include?(name)
+        decode_cursor(value)
+      else
+        value.to_i
+      end
+    end
+
+    def decode_cursor(cursor)
+      JSON.parse(Base64.decode64(cursor)).symbolize_keys
+    end
+
     # Try to find on this resource
     # If not there, follow the legacy logic of scalling all other
     # resource names/types
@@ -232,7 +252,7 @@ module Graphiti
       return true if @resource.remote?
 
       if (att = @resource.get_attr(name, flag, request: true))
-        return att
+        att
       else
         not_associated_name = !@resource.class.association_names.include?(name)
         not_associated_type = !@resource.class.association_types.include?(name)
@@ -262,8 +282,8 @@ module Graphiti
     def parse_fieldset(fieldset)
       {}.tap do |hash|
         fieldset.each_pair do |type, fields|
-          type       = type.to_sym
-          fields     = fields.split(",") unless fields.is_a?(Array)
+          type = type.to_sym
+          fields = fields.split(",") unless fields.is_a?(Array)
           hash[type] = fields.map(&:to_sym)
         end
       end
@@ -282,7 +302,7 @@ module Graphiti
 
     def sort_hash(attr)
       value = attr[0] == "-" ? :desc : :asc
-      key   = attr.sub("-", "").to_sym
+      key = attr.sub("-", "").to_sym
 
       {key => value}
     end
@@ -312,5 +332,17 @@ module Graphiti
         end
       end
     end
+
+    def parse_action(action)
+      action ||= @params.fetch(:action, Graphiti.context[:namespace]).try(:to_sym)
+      case action
+      when :index
+        :all
+      when :show
+        :find
+      else
+        action
+      end
+    end
   end
 end

data/lib/graphiti/railtie.rb

@@ -6,7 +6,7 @@ module Graphiti
     end
 
     generators do
-      Dir[File.expand_path("../../deprecated_generators/**/*.rb", __dir__)].each do |f|
+      Dir[File.expand_path("../../deprecated_generators/**/*.rb", __dir__)].sort.each do |f|
         require f
       end
     end
@@ -110,10 +110,10 @@ module Graphiti
         end
 
         route = begin
-                  ::Rails.application.routes.recognize_path(path, method: method)
-                rescue
-                  nil
-                end
+          ::Rails.application.routes.recognize_path(path, method: method)
+        rescue
+          nil
+        end
         "#{route[:controller]}_controller".classify.safe_constantize if route
       }
     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)
@@ -49,6 +66,7 @@ module Graphiti
         options[:meta] ||= proxy.meta
         options[:meta][:stats] = proxy.stats unless proxy.stats.empty?
         options[:meta][:debug] = Debugger.to_a if debug_json?
+        options[:proxy] = proxy
 
         renderer.render(records, options)
       end

data/lib/graphiti/request_validator.rb

@@ -1,23 +1,23 @@
 module Graphiti
   class RequestValidator
     delegate :validate,
-             :validate!,
-             :errors,
-             :deserialized_payload,
-             to: :@validator
+      :validate!,
+      :errors,
+      :deserialized_payload,
+      to: :@validator
 
-    def initialize(root_resource, raw_params)
-      @validator = ValidatorFactory.create(root_resource, raw_params)
+    def initialize(root_resource, raw_params, action)
+      @validator = ValidatorFactory.create(root_resource, raw_params, action)
     end
 
     class ValidatorFactory
-      def self.create(root_resource, raw_params)
-        case raw_params["action"]
-        when "update" then
+      def self.create(root_resource, raw_params, action)
+        case action
+        when :update
           RequestValidators::UpdateValidator
         else
           RequestValidators::Validator
-        end.new(root_resource, raw_params)
+        end.new(root_resource, raw_params, action)
       end
     end
   end

data/lib/graphiti/request_validators/update_validator.rb

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

data/lib/graphiti/request_validators/validator.rb

@@ -3,43 +3,47 @@ module Graphiti
     class Validator
       attr_reader :errors
 
-      def initialize(root_resource, raw_params)
+      def initialize(root_resource, raw_params, action)
         @root_resource = root_resource
-        @raw_params = raw_params
+        @params = normalized_params(raw_params)
         @errors = Graphiti::Util::SimpleErrors.new(raw_params)
+        @action = action
       end
 
       def validate
+        # Right now, all requests - even reads - go through the validator
+        # In the future these should have their own validation logic, but
+        # for now we can just bypass
+        return true unless @params.has_key?(:data)
+
         resource = @root_resource
-        if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
-          if @root_resource.type != meta_type && @root_resource.polymorphic?
-            resource = @root_resource.class.resource_for_type(meta_type).new
+
+        if @params[:data].has_key?(:type)
+          if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
+            if @root_resource.type != meta_type && @root_resource.polymorphic?
+              resource = @root_resource.class.resource_for_type(meta_type).new
+            end
           end
-        end
 
-        typecast_attributes(resource, deserialized_payload.attributes, deserialized_payload.meta[:payload_path])
-        process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+          typecast_attributes(resource, deserialized_payload.attributes, @action, deserialized_payload.meta[:payload_path])
+          process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+        else
+          errors.add(:"data.type", :missing)
+        end
 
         errors.blank?
       end
 
       def validate!
         unless validate
-          raise @error_class || Graphiti::Errors::InvalidRequest, self.errors
+          raise @error_class || Graphiti::Errors::InvalidRequest, errors
         end
 
         true
       end
 
       def deserialized_payload
-        @deserialized_payload ||= begin
-                                    payload = normalized_params
-                                    if payload[:data] && payload[:data][:type]
-                                      Graphiti::Deserializer.new(payload)
-                                    else
-                                      Graphiti::Deserializer.new({})
-                                    end
-                                  end
+        @deserialized_payload ||= Graphiti::Deserializer.new(@params)
       end
 
       private
@@ -47,10 +51,10 @@ module Graphiti
       def process_relationships(resource, relationships, payload_path)
         opts = {
           resource: resource,
-          relationships: relationships,
+          relationships: relationships
         }
 
-        Graphiti::Util::RelationshipPayload.iterate(opts) do |x|
+        Graphiti::Util::RelationshipPayload.iterate(**opts) do |x|
           sideload_def = x[:sideload]
 
           unless sideload_def.writable?
@@ -61,13 +65,23 @@ module Graphiti
             next
           end
 
-          typecast_attributes(x[:resource], x[:attributes], x[:meta][:payload_path])
-          process_relationships(x[:resource], x[:relationships], x[:meta][:payload_path])
+          resource = x[:resource]
+          attributes = x[:attributes]
+          relationships = x[:relationships]
+          payload_path = x[:meta][:payload_path]
+          action = x[:meta][:method]
+          typecast_attributes(resource, attributes, action, payload_path)
+          process_relationships(resource, relationships, payload_path)
         end
       end
 
-      def typecast_attributes(resource, attributes, payload_path)
+      def typecast_attributes(resource, attributes, action, payload_path)
         attributes.each_pair do |key, value|
+          # Only validate id if create action, otherwise it's only used for lookup
+          next if action != :create &&
+            key == :id &&
+            resource.class.config[:attributes][:id][:writable] == false
+
           begin
             attributes[key] = resource.typecast(key, value, :writable)
           rescue Graphiti::Errors::UnknownAttribute
@@ -80,8 +94,8 @@ module Graphiti
         end
       end
 
-      def normalized_params
-        normalized = @raw_params
+      def normalized_params(raw_params)
+        normalized = raw_params
         if normalized.respond_to?(:to_unsafe_h)
           normalized = normalized.to_unsafe_h.deep_symbolize_keys
         end

data/lib/graphiti/resource/configuration.rb

@@ -22,12 +22,20 @@ module Graphiti
         end
 
         def type=(val)
-          val = val && val.to_sym
+          val = val&.to_sym
           if (val = super)
             serializer.type(val)
           end
         end
 
+        def graphql_entrypoint=(val)
+          if val
+            super(val.to_s.camelize(:lower).to_sym)
+          else
+            super
+          end
+        end
+
         # The .stat call stores a proc based on adapter
         # So if we assign a new adapter, reconfigure
         def adapter=(val)
@@ -42,7 +50,7 @@ module Graphiti
             path: val,
             full_path: val,
             url: val,
-            actions: [:index, :show],
+            actions: [:index, :show]
           }
         end
 
@@ -82,7 +90,10 @@ module Graphiti
           :attributes_schema_by_default,
           :relationships_readable_by_default,
           :relationships_writable_by_default,
-          :filters_accept_nil_by_default
+          :filters_accept_nil_by_default,
+          :filters_deny_empty_by_default,
+          :graphql_entrypoint,
+          :cursor_paginatable
 
         class << self
           prepend Overrides
@@ -96,6 +107,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)
@@ -104,6 +116,7 @@ module Graphiti
           default(klass, :relationships_readable_by_default, true)
           default(klass, :relationships_writable_by_default, true)
           default(klass, :filters_accept_nil_by_default, false)
+          default(klass, :filters_deny_empty_by_default, false)
 
           unless klass.config[:attributes][:id]
             klass.attribute :id, :integer_id
@@ -127,7 +140,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?
@@ -142,19 +155,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
@@ -186,6 +200,7 @@ module Graphiti
           @config ||=
             {
               filters: {},
+              grouped_filters: {},
               default_filters: {},
               stats: {},
               sort_all: nil,
@@ -198,6 +213,7 @@ module Graphiti
               extra_attributes: {},
               sideloads: {},
               callbacks: {},
+              links: {}
             }
         end
 
@@ -221,6 +237,10 @@ module Graphiti
           config[:filters]
         end
 
+        def grouped_filters
+          config[:grouped_filters]
+        end
+
         def sorts
           config[:sorts]
         end
@@ -236,11 +256,15 @@ module Graphiti
         def default_filters
           config[:default_filters]
         end
+
+        def links
+          config[:links]
+        end
       end
 
       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)
@@ -255,6 +279,10 @@ module Graphiti
         self.class.filters
       end
 
+      def grouped_filters
+        self.class.grouped_filters
+      end
+
       def sort_all
         self.class.sort_all
       end