graphiti 1.2.31 → 1.3.4

data/lib/graphiti/query.rb

@@ -32,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
@@ -96,7 +98,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
@@ -178,12 +191,13 @@ module Graphiti
           (@params[:page] || {}).each_pair do |name, value|
             if legacy_nested?(name)
               value.each_pair do |k, v|
-                hash[k.to_sym] = v.to_i
+                hash[k.to_sym] = cast_page_param(k.to_sym, v)
               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
+              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
@@ -227,6 +241,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

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_validators/update_validator.rb

@@ -26,17 +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

@@ -5,21 +5,31 @@ module Graphiti
 
       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
@@ -33,14 +43,7 @@ module Graphiti
       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
@@ -62,15 +65,20 @@ 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 &&
+          next if action != :create &&
             key == :id &&
             resource.class.config[:attributes][:id][:writable] == false
 
@@ -86,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

@@ -28,6 +28,14 @@ module Graphiti
           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)
@@ -83,7 +91,9 @@ 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,
+          :cursor_paginatable
 
         class << self
           prepend Overrides
@@ -97,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)
@@ -144,6 +155,7 @@ module Graphiti
           if (@abstract_class = val)
             self.serializer = nil
             self.type = nil
+            self.graphql_entrypoint = nil
           end
         end
 
@@ -188,6 +200,7 @@ module Graphiti
           @config ||=
             {
               filters: {},
+              grouped_filters: {},
               default_filters: {},
               stats: {},
               sort_all: nil,
@@ -224,6 +237,10 @@ module Graphiti
           config[:filters]
         end
 
+        def grouped_filters
+          config[:grouped_filters]
+        end
+
         def sorts
           config[:sorts]
         end
@@ -262,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

data/lib/graphiti/resource/dsl.rb

@@ -9,7 +9,11 @@ module Graphiti
           opts = args.extract_options!
           type_override = args[0]
 
-          if (att = get_attr(name, :filterable, raise_error: :only_unsupported))
+          if (att = (attributes[name] || extra_attributes[name]))
+            # We're opting in to filtering, so force this
+            # UNLESS the filter is guarded at the attribute level
+            att[:filterable] = true if att[:filterable] == false
+
             aliases = [name, opts[:aliases]].flatten.compact
             operators = FilterOperators.build(self, att[:type], opts, &blk)
 
@@ -23,6 +27,8 @@ module Graphiti
             end
 
             required = att[:filterable] == :required || !!opts[:required]
+            schema = !!opts[:via_attribute_dsl] ? att[:schema] : opts[:schema] != false
+
             config[:filters][name.to_sym] = {
               aliases: aliases,
               name: name.to_sym,
@@ -32,6 +38,7 @@ module Graphiti
               single: !!opts[:single],
               dependencies: opts[:dependent],
               required: required,
+              schema: schema,
               operators: operators.to_hash,
               allow_nil: opts.fetch(:allow_nil, filters_accept_nil_by_default),
               deny_empty: opts.fetch(:deny_empty, filters_deny_empty_by_default)
@@ -44,6 +51,17 @@ module Graphiti
           end
         end
 
+        def filter_group(filter_names, *args)
+          opts = args.extract_options!
+
+          Scoping::FilterGroupValidator.raise_unless_filter_group_requirement_valid!(self, opts[:required])
+
+          config[:grouped_filters] = {
+            names: filter_names,
+            required: opts[:required]
+          }
+        end
+
         def sort_all(&blk)
           if block_given?
             config[:_sort_all] = blk
@@ -119,7 +137,7 @@ module Graphiti
           options[:sortable] ? sort(name) : config[:sorts].delete(name)
 
           if options[:filterable]
-            filter(name, allow: options[:allow])
+            filter(name, allow: options[:allow], via_attribute_dsl: true)
           else
             config[:filters].delete(name)
           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.rb

@@ -28,11 +28,12 @@ module Graphiti
       serializer
     end
 
-    def decorate_record(record)
+    def decorate_record(record, index = nil)
       unless record.instance_variable_get(:@__graphiti_serializer)
         serializer = serializer_for(record)
         record.instance_variable_set(:@__graphiti_serializer, serializer)
         record.instance_variable_set(:@__graphiti_resource, self)
+        record.instance_variable_set(:@__graphiti_index, index) if index
       end
     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,14 +90,20 @@ 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),
           sorts: sorts(r),
           filters: filters(r),
-          relationships: relationships(r)
+          relationships: relationships(r),
+          stats: stats(r)
         }
 
+        if r.grouped_filters.any?
+          config[:filter_group] = r.grouped_filters
+        end
+
         if r.default_sort
           default_sort = r.default_sort.map { |s|
             {s.keys.first.to_s => s.values.first.to_s}
@@ -108,7 +115,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
@@ -163,6 +170,14 @@ module Graphiti
       end
     end
 
+    def stats(resource)
+      {}.tap do |stats|
+        resource.stats.each_pair do |name, config|
+          stats[name] = config.calculations.keys
+        end
+      end
+    end
+
     def sorts(resource)
       {}.tap do |s|
         resource.sorts.each_pair do |name, sort|
@@ -182,7 +197,7 @@ module Graphiti
     def filters(resource)
       {}.tap do |f|
         resource.filters.each_pair do |name, filter|
-          next unless resource.attributes[name][:schema]
+          next unless resource.filters[name][:schema]
 
           config = {
             type: filter[:type].to_s,
@@ -202,11 +217,18 @@ module Graphiti
               config[:guard] = true
             end
           end
+          if filter[:required] # one-off filter, not attribute
+            config[:required] = true
+          end
           f[name] = config
         end
       end
     end
 
+    def filter_group(resource)
+      resource.config[:grouped_filters]
+    end
+
     def relationships(resource)
       {}.tap do |r|
         resource.sideloads.each_pair do |name, config|
@@ -214,6 +236,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/schema_diff.rb

@@ -1,8 +1,8 @@
 module Graphiti
   class SchemaDiff
     def initialize(old, new)
-      @old = old.deep_symbolize_keys
-      @new = new.deep_symbolize_keys
+      @old = JSON.parse(old.to_json).deep_symbolize_keys
+      @new = JSON.parse(new.to_json).deep_symbolize_keys
       @errors = []
     end
 
@@ -30,6 +30,8 @@ module Graphiti
           compare_extra_attributes(r, new_resource)
           compare_sorts(r, new_resource)
           compare_filters(r, new_resource)
+          compare_filter_group(r, new_resource)
+          compare_stats(r, new_resource)
           compare_relationships(r, new_resource)
         end
       end
@@ -133,12 +135,12 @@ module Graphiti
         end
 
         if new_sort[:only] && !old_sort[:only]
-          @errors << "#{old_resource[:name]}: sort #{name.inspect} now limited to only #{new_sort[:only].inspect}."
+          @errors << "#{old_resource[:name]}: sort #{name.inspect} now limited to only #{new_sort[:only].to_sym.inspect}."
         end
 
         if new_sort[:only] && old_sort[:only]
           if new_sort[:only] != old_sort[:only]
-            @errors << "#{old_resource[:name]}: sort #{name.inspect} was limited to only #{old_sort[:only].inspect}, now limited to only #{new_sort[:only].inspect}."
+            @errors << "#{old_resource[:name]}: sort #{name.inspect} was limited to only #{old_sort[:only].to_sym.inspect}, now limited to only #{new_sort[:only].to_sym.inspect}."
           end
         end
       end
@@ -204,6 +206,44 @@ module Graphiti
       end
     end
 
+    def compare_filter_group(old_resource, new_resource)
+      if new_resource[:filter_group]
+        if old_resource[:filter_group]
+          new_names = new_resource[:filter_group][:names]
+          old_names = old_resource[:filter_group][:names]
+          diff = new_names - old_names
+          if !diff.empty? && new_resource[:filter_group][:required] == "all"
+            @errors << "#{old_resource[:name]}: all required filter group #{old_names.map(&:to_sym).inspect} added #{"member".pluralize(diff.length)} #{diff.map(&:to_sym).inspect}."
+          end
+
+          old_required = old_resource[:filter_group][:required]
+          new_required = new_resource[:filter_group][:required]
+          if old_required == "any" && new_required == "all"
+            @errors << "#{old_resource[:name]}: filter group #{old_names.map(&:to_sym).inspect} moved from required: :any to required: :all"
+          end
+        else
+          @errors << "#{old_resource[:name]}: filter group #{new_resource[:filter_group][:names].map(&:to_sym).inspect} was added."
+        end
+      end
+    end
+
+    def compare_stats(old_resource, new_resource)
+      return unless old_resource.key?(:stats)
+
+      old_resource[:stats].each_pair do |name, old_calculations|
+        new_calculations = new_resource[:stats][name]
+        if new_calculations
+          old_calculations.each do |calc|
+            unless new_calculations.include?(calc)
+              @errors << "#{old_resource[:name]}: calculation #{calc.to_sym.inspect} was removed from stat #{name.inspect}."
+            end
+          end
+        else
+          @errors << "#{old_resource[:name]}: stat #{name.inspect} was removed."
+        end
+      end
+    end
+
     def compare_endpoints
       @old[:endpoints].each_pair do |path, old_endpoint|
         unless (new_endpoint = @new[:endpoints][path])

data/lib/graphiti/scope.rb

@@ -85,8 +85,8 @@ module Graphiti
     # Used to ensure the resource's serializer is used
     # Not one derived through the usual jsonapi-rb logic
     def assign_serializer(records)
-      records.each do |r|
-        @resource.decorate_record(r)
+      records.each_with_index do |r, index|
+        @resource.decorate_record(r, index)
       end
     end
 

data/lib/graphiti/scoping/filter.rb

@@ -3,6 +3,13 @@ module Graphiti
     include Scoping::Filterable
 
     def apply
+      unless @opts[:bypass_required_filters]
+        Graphiti::Scoping::FilterGroupValidator.new(
+          resource,
+          query_hash
+        ).raise_unless_filter_group_requirements_met!
+      end
+
       if missing_required_filters.any? && !@opts[:bypass_required_filters]
         raise Errors::RequiredFilter.new(resource, missing_required_filters)
       end
@@ -164,14 +171,18 @@ module Graphiti
       type = Graphiti::Types[filter[:type]]
       array_or_string = [:string, :array].include?(type[:canonical_name])
       if (arr = value.scan(/\[.*?\]/)).present? && array_or_string
-        value = arr.map { |json|
-          begin
-            JSON.parse(json)
-          rescue
-            raise Errors::InvalidJSONArray.new(resource, value)
-          end
-        }
-        value = value[0] if value.length == 1
+        begin
+          value = arr.map { |json|
+            begin
+              JSON.parse(json)
+            rescue
+              raise Errors::InvalidJSONArray.new(resource, value)
+            end
+          }
+          value = value[0] if value.length == 1
+        rescue Errors::InvalidJSONArray => e
+          raise(e) if type[:canonical_name] == :array
+        end
       else
         value = parse_string_arrays(value, !!filter[:single])
       end