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

data/lib/generators/graphiti/templates/show_request_spec.rb.erb

@@ -0,0 +1,21 @@
+require 'rails_helper'
+
+RSpec.describe "<%= type %>#show", type: :request do
+  let(:params) { {} }
+
+  subject(:make_request) do
+    jsonapi_get "/<%= api_namespace %>/v1/<%= type %>/#{<%= var %>.id}", params: params
+  end
+
+  describe 'basic fetch' do
+    let!(:<%= var %>) { create(:<%= var %>) }
+
+    it 'works' do
+      expect(<%= resource_class %>).to receive(:find).and_call_original
+      make_request
+      expect(response.status).to eq(200)
+      expect(d.jsonapi_type).to eq('<%= type %>')
+      expect(d.id).to eq(<%= var %>.id)
+    end
+  end
+end

data/lib/generators/{jsonapi → graphiti}/templates/update_request_spec.rb.erb

@@ -2,16 +2,16 @@ require 'rails_helper'
 
 RSpec.describe "<%= type %>#update", type: :request do
   subject(:make_request) do
-    jsonapi_put "/<%= api_namespace %>/v1/<%= type %>/#{<%= file_name %>.id}", payload
+    jsonapi_put "/<%= api_namespace %>/v1/<%= type %>/#{<%= var %>.id}", payload
   end
 
   describe 'basic update' do
-    let!(:<%= file_name %>) { create(:<%= file_name %>) }
+    let!(:<%= var %>) { create(:<%= var %>) }
 
     let(:payload) do
       {
         data: {
-          id: <%= file_name %>.id.to_s,
+          id: <%= var %>.id.to_s,
           type: '<%= type %>',
           attributes: {
             # ... your attrs here
@@ -22,10 +22,10 @@ RSpec.describe "<%= type %>#update", type: :request do
 
     # Replace 'xit' with 'it' after adding attributes
     xit 'updates the resource' do
-      expect(<%= resource_klass %>).to receive(:find).and_call_original
+      expect(<%= resource_class %>).to receive(:find).and_call_original
       expect {
         make_request
-      }.to change { <%= file_name %>.reload.attributes }
+      }.to change { <%= var %>.reload.attributes }
       expect(response.status).to eq(200)
 
       # ... assert updates attributes ...

data/lib/graphiti.rb

@@ -126,12 +126,6 @@ module Graphiti
   def self.resources
     @resources ||= []
   end
-
-  def self.check!
-    resources.each do |resource|
-      resource.sideloads.values.each(&:check!)
-    end
-  end
 end
 
 require "graphiti/runner"

data/lib/graphiti/adapters/abstract.rb

@@ -475,7 +475,6 @@ module Graphiti
       def activerecord_associate?(parent, child, association_name)
         defined?(::ActiveRecord) &&
           parent.is_a?(::ActiveRecord::Base) &&
-          child.is_a?(::ActiveRecord::Base) &&
           parent.class.reflect_on_association(association_name)
       end
     end

data/lib/graphiti/adapters/active_record/inferrence.rb

@@ -2,9 +2,16 @@ module Graphiti
   module Adapters
     module ActiveRecord
       module Inferrence
+        # If going AR to AR, use AR introspection
+        # If going AR to PORO, fall back to normal inferrence
         def infer_foreign_key
           parent_model = parent_resource_class.model
-          parent_model.reflections[association_name.to_s].foreign_key.to_sym
+          reflection = parent_model.reflections[association_name.to_s]
+          if reflection
+            reflection.foreign_key.to_sym
+          else
+            super
+          end
         end
       end
     end

data/lib/graphiti/base.rb

@@ -11,7 +11,7 @@ module Graphiti
     end
 
     def query_hash
-      @query_hash ||= query.to_hash
+      @query_hash ||= query.hash
     end
 
     def wrap_context

data/lib/graphiti/errors.rb

@@ -16,6 +16,53 @@ The adapter #{@adapter.class} does not implement method '#{@method}', which was
       end
     end
 
+    class SingularSideload < Base
+      def initialize(sideload, parent_length)
+        @sideload = sideload
+        @parent_length = parent_length
+      end
+
+      def message
+        <<-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
+
+You might have done this because the sideload can only be loaded from a :show endpoint, and :index would be too expensive.
+
+Remove the single: true option to bypass this error.
+        MSG
+      end
+    end
+
+    class UnsupportedSort < Base
+      def initialize(resource, attribute, whitelist, direction)
+        @resource = resource
+        @attribute = attribute
+        @whitelist = whitelist
+        @direction = direction
+      end
+
+      def message
+        <<-MSG
+#{@resource.class.name}: tried to sort on attribute #{@attribute.inspect}, but passed #{@direction.inspect} when only #{@whitelist.inspect} is supported.
+        MSG
+      end
+    end
+
+    class ExtraAttributeNotFound < Base
+      def initialize(resource_class, name)
+        @resource_class = resource_class
+        @name = name
+      end
+
+      def message
+        <<-MSG
+#{@resource_class.name}: called .on_extra_attribute #{@name.inspect}, but extra attribute #{@name.inspect} does not exist!
+        MSG
+      end
+    end
+
     class InvalidFilterValue < Base
       def initialize(resource, filter, value)
         @resource = resource
@@ -158,7 +205,7 @@ Graphiti.config.context_for_endpoint = ->(path, action) { ... }
 
 Either set a primary endpoint for this resource:
 
-endpoint '/my/url', [:index, :show, :create]
+primary_endpoint '/my/url', [:index, :show, :create]
 
 Or whitelist a secondary endpoint:
 
@@ -347,16 +394,34 @@ Expecting filter #{@filter.inspect} on #{@sideload.resource.class.name}.
       end
     end
 
+    class MissingDependentFilter < Base
+      def initialize(resource, filters)
+        @resource = resource
+        @filters = filters
+      end
+
+      def message
+        msg = "#{@resource.class.name}: The following filters had dependencies that were not passed:"
+        @filters.each do |f|
+          msg << "\n#{f[:filter][:name].inspect} - dependent on #{f[:filter][:dependencies].inspect}, but #{f[:missing].inspect} not passed."
+        end
+        msg
+      end
+    end
+
     class ResourceNotFound < Base
-      def initialize(resource_class, sideload_name)
+      def initialize(resource_class, sideload_name, tried)
         @resource_class = resource_class
         @sideload_name = sideload_name
+        @tried = tried
       end
 
       def message
         <<-MSG
 Could not find resource class for sideload '#{@sideload_name}' on Resource '#{@resource_class.name}'!
 
+Tried to find classes: #{@tried.join(', ')}
+
 If this follows a non-standard naming convention, use the :resource option to pass it directly:
 
 has_many :comments, resource: SpecialCommentResource
@@ -395,13 +460,13 @@ Consider using a named relationship instead, e.g. 'has_one :top_comment'
     end
 
     class InvalidInclude < Base
-      def initialize(relationship, parent_resource)
+      def initialize(resource_class, relationship)
+        @resource_class = resource_class
         @relationship = relationship
-        @parent_resource = parent_resource
       end
 
       def message
-        "The requested included relationship \"#{@relationship}\" is not supported on resource \"#{@parent_resource}\""
+"#{@resource_class.name}: The requested included relationship \"#{@relationship}\" is not supported."
       end
     end
 

data/lib/graphiti/jsonapi_serializable_ext.rb

@@ -7,8 +7,9 @@ module Graphiti
     # To ensure we always render with the *resource* serializer
     module RendererOverrides
       def _build(object, exposures, klass)
-        klass = object.instance_variable_get(:@__serializer_klass)
-        klass.new(exposures.merge(object: object))
+        resource = object.instance_variable_get(:@__graphiti_resource)
+        klass = object.instance_variable_get(:@__graphiti_serializer)
+        klass.new(exposures.merge(object: object, resource: resource))
       end
     end
 
@@ -21,12 +22,14 @@ module Graphiti
             nil
           elsif resources.respond_to?(:to_ary)
             Array(resources).map do |obj|
-              klass = obj.instance_variable_get(:@__serializer_klass)
-              klass.new(@_exposures.merge(object: obj))
+              klass = obj.instance_variable_get(:@__graphiti_serializer)
+              resource = obj.instance_variable_get(:@__graphiti_resource)
+              klass.new(@_exposures.merge(object: obj, resource: resource))
             end
           else
-            klass = resources.instance_variable_get(:@__serializer_klass)
-            klass.new(@_exposures.merge(object: resources))
+            klass = resources.instance_variable_get(:@__graphiti_serializer)
+            resource = resources.instance_variable_get(:@__graphiti_resource)
+            klass.new(@_exposures.merge(object: resources, resource: resource))
           end
         end
       end
@@ -38,6 +41,15 @@ module Graphiti
       def requested_relationships(fields)
         @_relationships
       end
+
+      # Allow access to resource methods
+      def method_missing(id, *args, &blk)
+        if @resource.respond_to?(id, true)
+          @resource.send(id, *args, &blk)
+        else
+          super
+        end
+      end
     end
 
     JSONAPI::Serializable::Resource

data/lib/graphiti/query.rb

@@ -1,6 +1,6 @@
 module Graphiti
   class Query
-    attr_reader :resource, :include_hash, :association_name
+    attr_reader :resource, :include_hash, :association_name, :params
 
     def initialize(resource, params, association_name = nil, nested_include = nil, parents = [])
       @resource = resource
@@ -29,17 +29,17 @@ module Graphiti
       end
     end
 
-    def to_hash
-      {}.tap do |hash|
-        hash[:filter] = filters unless filters.empty?
-        hash[:sort] = sorts unless sorts.empty?
-        hash[:page] = pagination unless pagination.empty?
+    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?
-          hash[:fields] = fields unless fields.empty?
-          hash[:extra_fields] = extra_fields unless extra_fields.empty?
+          h[:fields] = fields unless fields.empty?
+          h[:extra_fields] = extra_fields unless extra_fields.empty?
         end
-        hash[:stats] = stats unless stats.empty?
-        hash[:include] = sideload_hash unless sideload_hash.empty?
+        h[:stats] = stats unless stats.empty?
+        h[:include] = sideload_hash unless sideload_hash.empty?
       end
     end
 
@@ -53,7 +53,7 @@ module Graphiti
       @sideload_hash = begin
         {}.tap do |hash|
           sideloads.each_pair do |key, value|
-            hash[key] = sideloads[key].to_hash
+            hash[key] = sideloads[key].hash
           end
         end
       end
@@ -66,6 +66,7 @@ module Graphiti
             sideload = @resource.class.sideload(key)
             if sideload
               _parents = parents + [self]
+              sub_hash = sub_hash[:include] if sub_hash.has_key?(:include)
               hash[key] = Query.new(sideload.resource, @params, key, sub_hash, _parents)
             else
               handle_missing_sideload(key)
@@ -163,6 +164,8 @@ module Graphiti
 
         whitelist ? Util::IncludeParams.scrub(requested, whitelist) : requested
       end
+
+      @include_hash
     end
 
     def stats
@@ -182,17 +185,25 @@ module Graphiti
 
     private
 
+    # Try to find on this resource
+    # If not there, follow the legacy logic of scalling all other
+    # resource names/types
+    # TODO: Eventually, remove the legacy logic
     def validate!(name, flag)
       return false if name.to_s.include?('.') # nested
 
-      not_associated_name = !@resource.class.association_names.include?(name)
-      not_associated_type = !@resource.class.association_types.include?(name)
+      if att = @resource.get_attr(name, flag, request: true)
+        return att
+      else
+        not_associated_name = !@resource.class.association_names.include?(name)
+        not_associated_type = !@resource.class.association_types.include?(name)
 
-      if not_associated_name && not_associated_type
-        @resource.get_attr!(name, flag, request: true)
-        return true
+        if not_associated_name && not_associated_type
+          @resource.get_attr!(name, flag, request: true)
+          return true
+        end
+        false
       end
-      false
     end
 
     def nested?(name)

data/lib/graphiti/resource.rb

@@ -9,6 +9,14 @@ module Graphiti
     attr_reader :context
 
     def around_scoping(scope, query_hash)
+      extra_fields = query_hash[:extra_fields] || {}
+      extra_fields = extra_fields[type] || []
+      extra_fields.each do |name|
+        if config = self.class.config[:extra_attributes][name]
+          scope = instance_exec(scope, &config[:hook]) if config[:hook]
+        end
+      end
+
       yield scope
     end
 
@@ -16,6 +24,12 @@ module Graphiti
       serializer
     end
 
+    def decorate_record(record)
+      serializer = serializer_for(record)
+      record.instance_variable_set(:@__graphiti_serializer, serializer)
+      record.instance_variable_set(:@__graphiti_resource, self)
+    end
+
     def with_context(object, namespace = nil)
       Graphiti.with_context(object, namespace) do
         yield

data/lib/graphiti/resource/configuration.rb

@@ -3,6 +3,8 @@ module Graphiti
     module Configuration
       extend ActiveSupport::Concern
 
+      DEFAULT_MAX_PAGE_SIZE = 1_000
+
       module Overrides
         def serializer=(val)
           if val
@@ -52,6 +54,7 @@ module Graphiti
           :serializer,
           :default_page_size,
           :default_sort,
+          :max_page_size,
           :attributes_readable_by_default,
           :attributes_writable_by_default,
           :attributes_sortable_by_default,
@@ -67,13 +70,12 @@ module Graphiti
           super
           klass.config = Util::Hash.deep_dup(config)
           klass.adapter ||= Adapters::Abstract
-          klass.default_sort ||= []
-          klass.default_page_size ||= 20
+          klass.max_page_size ||= DEFAULT_MAX_PAGE_SIZE
           # re-assigning causes a new Class.new
           if klass.serializer
             klass.serializer = klass.serializer
           else
-            klass.serializer = JSONAPI::Serializable::Resource
+            klass.serializer = klass.infer_serializer_superclass
           end
           klass.type ||= klass.infer_type
           default(klass, :attributes_readable_by_default, true)
@@ -130,6 +132,23 @@ module Graphiti
           name.gsub('Resource', '').safe_constantize if name
         end
 
+        # @api private
+        def infer_serializer_superclass
+          serializer_class = JSONAPI::Serializable::Resource
+          namespace = Util::Class.namespace_for(self)
+          app_serializer = "#{namespace}::ApplicationSerializer"
+            .safe_constantize
+          app_serializer ||= "ApplicationSerializer".safe_constantize
+
+          if app_serializer
+            if app_serializer.ancestors.include?(serializer_class)
+              serializer_class = app_serializer
+            end
+          end
+
+          serializer_class
+        end
+
         def default(object, attr, value)
           prior = object.send(attr)
           unless prior || prior == false

data/lib/graphiti/resource/dsl.rb

@@ -15,12 +15,16 @@ module Graphiti
               opts[:single] = true
             end
 
+            required = att[:filterable] == :required || !!opts[:required]
             config[:filters][name.to_sym] = {
               aliases: aliases,
+              name: name.to_sym,
               type: att[:type],
               allow: opts[:allow],
               reject: opts[:reject],
               single: !!opts[:single],
+              dependencies: opts[:dependent],
+              required: required,
               operators: operators.to_hash
             }
           else
@@ -45,7 +49,9 @@ module Graphiti
           opts = args.extract_options!
 
           if get_attr(name, :sortable, raise_error: :only_unsupported)
-            config[:sorts][name] = blk
+            config[:sorts][name] = {
+              proc: blk
+            }.merge(opts.slice(:only))
           else
             if type = args[0]
               attribute name, type, only: [:sortable]
@@ -89,7 +95,8 @@ module Graphiti
           options[:proc] = blk
           config[:attributes][name] = options
           apply_attributes_to_serializer
-          filter(name) if options[:filterable]
+          options[:filterable] ? filter(name) : config[:filters].delete(name)
+          options[:sortable] ? sort(name) : config[:sorts].delete(name)
         end
 
         def extra_attribute(name, type, options = {}, &blk)
@@ -107,6 +114,14 @@ module Graphiti
           apply_extra_attributes_to_serializer
         end
 
+        def on_extra_attribute(name, &blk)
+          if config[:extra_attributes][name]
+            config[:extra_attributes][name][:hook] = blk
+          else
+            raise Errors::ExtraAttributeNotFound.new(self, name)
+          end
+        end
+
         def all_attributes
           attributes.merge(extra_attributes)
         end