graphiti 1.0.alpha.5 → 1.0.alpha.6

data/lib/graphiti/resource/interface.rb

@@ -5,38 +5,40 @@ module Graphiti
 
       class_methods do
         def all(params = {}, base_scope = nil)
-          validate!
+          validate!(params)
           _all(params, {}, base_scope)
         end
 
         # @api private
         def _all(params, opts, base_scope)
-          runner = Runner.new(self, params)
+          runner = Runner.new(self, params, opts.delete(:query))
           runner.proxy(base_scope, opts)
         end
 
-        def find(params, base_scope = nil)
-          validate!
+        def find(params = {}, base_scope = nil)
+          validate!(params)
           id = params[:data].try(:[], :id) || params.delete(:id)
           params[:filter] ||= {}
-          params[:filter].merge!(id: id)
+          params[:filter].merge!(id: id) if id
 
           runner = Runner.new(self, params)
           runner.proxy(base_scope, single: true, raise_on_missing: true)
         end
 
         def build(params, base_scope = nil)
-          validate!
+          validate!(params)
           runner = Runner.new(self, params)
           runner.proxy(base_scope, single: true, raise_on_missing: true)
         end
 
         private
 
-        def validate!
+        def validate!(params)
+          return unless validate_endpoints?
+
           if context && context.respond_to?(:request)
             path = context.request.env['PATH_INFO']
-            unless allow_request?(path, context_namespace)
+            unless allow_request?(path, params, context_namespace)
               raise Errors::InvalidEndpoint.new(self, path, context_namespace)
             end
           end

data/lib/graphiti/resource/links.rb

@@ -19,9 +19,11 @@ module Graphiti
         :base_url,
         :endpoint_namespace,
         :secondary_endpoints,
-        :autolink
+        :autolink,
+        :validate_endpoints
       self.secondary_endpoints = []
       self.autolink = true
+      self.validate_endpoints = true
 
       class << self
         prepend Overrides
@@ -66,9 +68,10 @@ module Graphiti
         ([endpoint] + secondary_endpoints).compact
       end
 
-      def allow_request?(path, action)
+      def allow_request?(path, params, action)
         endpoints.any? do |e|
-          if [:update, :show, :destroy].include?(context_namespace)
+          has_id = params[:id] || params[:data].try(:[], :id)
+          if [:update, :show, :destroy].include?(context_namespace) && has_id
             path = path.split('/')
             path.pop
             path = path.join('/')

data/lib/graphiti/runner.rb

@@ -3,9 +3,10 @@ module Graphiti
     attr_reader :params
     include Graphiti::Base
 
-    def initialize(resource_class, params)
+    def initialize(resource_class, params, query = nil)
       @resource_class = resource_class
       @params = params
+      @query = query
     end
 
     def jsonapi_resource

data/lib/graphiti/schema.rb

@@ -84,10 +84,19 @@ module Graphiti
           type: r.type.to_s,
           attributes: attributes(r),
           extra_attributes: extra_attributes(r),
+          sorts: sorts(r),
           filters: filters(r),
           relationships: relationships(r)
         }
 
+        if r.default_sort
+          config[:default_sort] = r.default_sort
+        end
+
+        if r.default_page_size
+          config[:default_page_size] = r.default_page_size
+        end
+
         if r.polymorphic?
           config.merge!(polymorphic: true, children: r.children.map(&:name))
         end
@@ -99,12 +108,11 @@ module Graphiti
     def attributes(resource)
       {}.tap do |attrs|
         resource.attributes.each_pair do |name, config|
-          if config.values_at(:readable, :writable, :sortable).any?
+          if config.values_at(:readable, :writable).any?
             attrs[name] = {
               type:       config[:type].to_s,
               readable:   flag(config[:readable]),
-              writable:   flag(config[:writable]),
-              sortable:   flag(config[:sortable])
+              writable:   flag(config[:writable])
             }
           end
         end
@@ -130,6 +138,20 @@ module Graphiti
       end
     end
 
+    def sorts(resource)
+      {}.tap do |s|
+        resource.sorts.each_pair do |name, sort|
+          config = {}
+          config[:only] = sort[:only] if sort[:only]
+          attr = resource.attributes[name]
+          if attr[:sortable].is_a?(Symbol)
+            config[:guard] = true
+          end
+          s[name] = config
+        end
+      end
+    end
+
     def filters(resource)
       {}.tap do |f|
         resource.filters.each_pair do |name, filter|
@@ -137,9 +159,11 @@ module Graphiti
             type: filter[:type].to_s,
             operators: filter[:operators].keys.map(&:to_s)
           }
+
           config[:single] = true if filter[:single]
-          config[:allow] = filter[:allow] if filter[:allow]
-          config[:reject] = filter[:reject] if filter[:reject]
+          config[:allow] = filter[:allow].map(&:to_s) if filter[:allow]
+          config[:reject] = filter[:reject].map(&:to_s) if filter[:reject]
+          config[:dependencies] = filter[:dependencies].map(&:to_s) if filter[:dependencies]
 
           attr = resource.attributes[name]
           if attr[:filterable].is_a?(Symbol)
@@ -165,6 +189,10 @@ module Graphiti
             schema[:resource] = config.resource.class.name
           end
 
+          if config.single?
+            schema[:single] = true
+          end
+
           r[name] = schema
         end
       end

data/lib/graphiti/schema_diff.rb

@@ -24,7 +24,9 @@ module Graphiti
         new_resource = @new[:resources].find { |n| n[:name] == r[:name] }
         compare_resource(r, new_resource) do
           compare_attributes(r, new_resource)
+          compare_defaults(r, new_resource)
           compare_extra_attributes(r, new_resource)
+          compare_sorts(r, new_resource)
           compare_filters(r, new_resource)
           compare_relationships(r, new_resource)
         end
@@ -54,6 +56,36 @@ module Graphiti
       end
     end
 
+    def compare_defaults(old_resource, new_resource)
+      if new_resource[:default_sort] && !old_resource[:default_sort]
+        @errors << "#{old_resource[:name]}: default sort added."
+      end
+
+      if old_resource[:default_sort] && !new_resource[:default_sort]
+        @errors << "#{old_resource[:name]}: default sort removed."
+      end
+
+      if new_resource[:default_sort] && old_resource[:default_sort]
+        if new_resource[:default_sort] != old_resource[:default_sort]
+          @errors << "#{old_resource[:name]}: default sort changed from #{old_resource[:default_sort].inspect} to #{new_resource[:default_sort].inspect}."
+        end
+      end
+
+      if new_resource[:default_page_size] && !old_resource[:default_page_size]
+        @errors << "#{old_resource[:name]}: default page size added."
+      end
+
+      if old_resource[:default_page_size] && !new_resource[:default_page_size]
+        @errors << "#{old_resource[:name]}: default page size removed."
+      end
+
+      if old_resource[:default_page_size] && new_resource[:default_page_size]
+        if old_resource[:default_page_size] != new_resource[:default_page_size]
+          @errors << "#{old_resource[:name]}: default page size changed from #{old_resource[:default_page_size]} to #{new_resource[:default_page_size]}."
+        end
+      end
+    end
+
     def compare_relationships(old_resource, new_resource)
       old_resource[:relationships].each_pair do |name, old_rel|
         unless new_rel = new_resource[:relationships][name]
@@ -61,6 +93,11 @@ module Graphiti
           next
         end
 
+        if new_rel[:single] && !old_rel[:single]
+          @errors << "#{old_resource[:name]}: relationship #{name.inspect} became single: true."
+          next
+        end
+
         if new_rel[:resource] != old_rel[:resource]
           @errors << "#{old_resource[:name]}: relationship #{name.inspect} changed resource from #{old_rel[:resource]} to #{new_rel[:resource]}."
         end
@@ -82,6 +119,29 @@ module Graphiti
       end
     end
 
+    def compare_sorts(old_resource, new_resource)
+      old_resource[:sorts].each_pair do |name, old_sort|
+        unless new_sort = new_resource[:sorts][name]
+          @errors << "#{old_resource[:name]}: sort #{name.inspect} was removed."
+          next
+        end
+
+        if new_sort[:guard] && !old_sort[:guard]
+          @errors << "#{old_resource[:name]}: sort #{name.inspect} became guarded."
+        end
+
+        if new_sort[:only] && !old_sort[:only]
+          @errors << "#{old_resource[:name]}: sort #{name.inspect} now limited to only #{new_sort[:only].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}."
+          end
+        end
+      end
+    end
+
     def compare_filters(old_resource, new_resource)
       old_resource[:filters].each_pair do |name, old_filter|
         unless new_filter = new_resource[:filters][name]
@@ -98,6 +158,16 @@ module Graphiti
           @errors << "#{old_resource[:name]}: filter #{name.inspect} became singular."
         end
 
+        if new_filter[:dependencies] && !old_filter[:dependencies]
+          @errors << "#{old_resource[:name]}: filter #{name.inspect} added dependencies #{new_filter[:dependencies].inspect}."
+        end
+
+        if new_filter[:dependencies] && old_filter[:dependencies]
+          if new_filter[:dependencies] != old_filter[:dependenices]
+            @errors << "#{old_resource[:name]}: filter #{name.inspect} changed dependencies from #{old_filter[:dependencies].inspect} to #{new_filter[:dependencies].inspect}."
+          end
+        end
+
         if new_filter[:allow] != old_filter[:allow]
           new = new_filter[:allow] || []
           old = old_filter[:allow] || []
@@ -182,7 +252,7 @@ module Graphiti
         @errors << "#{resource_name}: #{prefix} #{att_name.inspect} changed type from #{old_att[:type].inspect} to #{new_att[:type].inspect}."
       end
 
-      [:readable, :writable, :sortable].each do |flag|
+      [:readable, :writable].each do |flag|
         if [true, 'guarded'].include?(old_att[flag]) && new_att[flag] == false
           @errors << "#{resource_name}: #{prefix} #{att_name.inspect} changed flag #{flag.inspect} from #{old_att[flag].inspect} to #{new_att[flag].inspect}."
         end

data/lib/graphiti/scope.rb

@@ -8,13 +8,13 @@ module Graphiti
       @query     = query
       @opts      = opts
 
-      @object = @resource.around_scoping(@object, query_hash) do |scope|
+      @object = @resource.around_scoping(@object, @query.hash) do |scope|
         apply_scoping(scope, opts)
       end
     end
 
     def resolve_stats
-      if query_hash[:stats]
+      if @query.hash[:stats]
         Stats::Payload.new(@resource, @query, @unpaginated_object).generate
       else
         {}
@@ -36,18 +36,13 @@ module Graphiti
       end
     end
 
-    def query_hash
-      @query_hash ||= @query.to_hash
-    end
-
     private
 
     # 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|
-        serializer = @resource.serializer_for(r)
-        r.instance_variable_set(:@__serializer_klass, serializer)
+        @resource.decorate_record(r)
       end
     end
 
@@ -91,7 +86,7 @@ module Graphiti
     end
 
     def add_scoping(key, scoping_class, opts, default = {})
-      @object = scoping_class.new(@resource, query_hash, @object, opts).apply
+      @object = scoping_class.new(@resource, @query.hash, @object, opts).apply
       @unpaginated_object = @object unless key == :paginate
     end
   end

data/lib/graphiti/scoping/base.rb

@@ -6,7 +6,7 @@ module Graphiti
     # a default if not part of the user request.
     #
     # @attr_reader [Resource] resource The corresponding Resource instance
-    # @attr_reader [Hash] query_hash the Query#to_hash node relevant to the current resource
+    # @attr_reader [Hash] query_hash the Query#hash node relevant to the current resource
     #
     # @see Scoping::DefaultFilter
     # @see Scoping::ExtraFields
@@ -15,7 +15,7 @@ module Graphiti
     # @see Scoping::Sort
     # @see Scope#initialize
     # @see Scope#query_hash
-    # @see Query#to_hash
+    # @see Query#hash
     class Base
       attr_reader :resource, :query_hash
 

data/lib/graphiti/scoping/filter.rb

@@ -32,6 +32,11 @@ module Graphiti
         raise Errors::RequiredFilter.new(resource, missing_required_filters)
       end
 
+      if missing_dependent_filters.any?
+        raise Errors::MissingDependentFilter.new \
+          resource, missing_dependent_filters
+      end
+
       each_filter do |filter, operator, value|
         @scope = filter_scope(filter, operator, value)
       end

data/lib/graphiti/scoping/filterable.rb

@@ -20,17 +20,32 @@ module Graphiti
     end
 
     def missing_required_filters
-      required_attributes - filter_param.keys
+      required_filters - filter_param.keys
     end
 
-    def required_attributes
-      resource.attributes.map do |k, v|
-        k if v[:filterable] == :required
+    def required_filters
+      resource.filters.map do |k, v|
+        k if v[:required]
       end.compact
     end
 
-    def required_filters_provided?
-      missing_required_filters.empty?
+    def missing_dependent_filters
+      [].tap do |arr|
+        filter_param.each_pair do |key, value|
+          if df = dependent_filters[key]
+            missing = df[:dependencies] - filter_param.keys
+            unless missing.length.zero?
+              arr << { filter: df, missing: missing }
+            end
+          end
+        end
+      end
+    end
+
+    def dependent_filters
+      resource.filters.select do |k, v|
+        v[:dependencies].present?
+      end
     end
   end
 end

data/lib/graphiti/scoping/paginate.rb

@@ -23,14 +23,14 @@ module Graphiti
   # We should use the default unless the user has customized.
   # @see Resource.paginate
   class Scoping::Paginate < Scoping::Base
-    MAX_PAGE_SIZE = 1_000
+    DEFAULT_PAGE_SIZE = 20
 
     # Apply the pagination logic. Raise error if over the max page size.
     # @return the scope object we are chaining/modifying
     def apply
-      if size > MAX_PAGE_SIZE
+      if size > resource.max_page_size
         raise Graphiti::Errors::UnsupportedPageSize
-          .new(size, MAX_PAGE_SIZE)
+          .new(size, resource.max_page_size)
       elsif requested? && @opts[:sideload_parent_length].to_i > 1
         raise Graphiti::Errors::UnsupportedPagination
       else
@@ -81,7 +81,7 @@ module Graphiti
     end
 
     def size
-      (page_param[:size] || resource.default_page_size).to_i
+      (page_param[:size] || resource.default_page_size || DEFAULT_PAGE_SIZE).to_i
     end
   end
 end

data/lib/graphiti/scoping/sort.rb

@@ -22,10 +22,16 @@ module Graphiti
     # @return the scope we are chaining/modifying
     def apply_standard_scope
       each_sort do |attribute, direction|
-        if sort = resource.sorts[attribute]
-          @scope = sort.call(@scope, direction)
+        sort = resource.sorts[attribute]
+        if sort[:only] && sort[:only] != direction
+          raise Errors::UnsupportedSort.new resource,
+            attribute, sort[:only], direction
         else
-          @scope = resource.adapter.order(@scope, attribute, direction)
+          if sort[:proc]
+            @scope = sort[:proc].call(@scope, direction)
+          else
+            @scope = resource.adapter.order(@scope, attribute, direction)
+          end
         end
       end
       @scope
@@ -54,11 +60,26 @@ module Graphiti
     def sort_param
       @sort_param ||= begin
         if query_hash[:sort].blank?
-          resource.default_sort
+          resource.default_sort || []
         else
-          query_hash[:sort]
+          normalize(query_hash[:sort])
         end
       end
     end
+
+    def normalize(sort)
+      return sort if sort.is_a?(Array)
+      sorts = sort.split(',')
+      sorts.map do |s|
+        sort_hash(s)
+      end
+    end
+
+    def sort_hash(attr)
+      value = attr[0] == '-' ? :desc : :asc
+      key   = attr.sub('-', '').to_sym
+
+      { key => value }
+    end
   end
 end