graphiti-rb 1.0.alpha.1

data/lib/graphiti/responders.rb

@@ -0,0 +1,19 @@
+# If you're using Rails + responders gem to get respond_with
+module Graphiti
+  module Responders
+    extend ActiveSupport::Concern
+
+    included do
+      include ActionController::MimeResponds
+      respond_to(*Graphiti.config.respond_to)
+    end
+
+    # Override to avoid location url generation (for now)
+    def respond_with(*args, &blk)
+      opts = args.extract_options!
+      opts[:location] = nil
+      args << opts
+      super(*args, &blk)
+    end
+  end
+end

data/lib/graphiti/runner.rb

@@ -0,0 +1,25 @@
+module Graphiti
+  class Runner
+    attr_reader :params
+    include Graphiti::Base
+
+    def initialize(resource_class, params)
+      @resource_class = resource_class
+      @params = params
+    end
+
+    def jsonapi_resource
+      @jsonapi_resource ||= @resource_class.new
+    end
+
+    # Typically, this is 'self' of a controller
+    # We're overriding here so we can do stuff like
+    #
+    # Graphiti.with_context my_context, {} do
+    #   Runner.new ...
+    # end
+    def jsonapi_context
+      Graphiti.context[:object]
+    end
+  end
+end

data/lib/graphiti/scope.rb

@@ -0,0 +1,98 @@
+module Graphiti
+  class Scope
+    attr_accessor :object, :unpaginated_object
+
+    def initialize(object, resource, query, opts = {})
+      @object    = object
+      @resource  = resource
+      @query     = query
+      @opts      = opts
+
+      @object = @resource.around_scoping(@object, query_hash) do |scope|
+        apply_scoping(scope, opts)
+      end
+    end
+
+    def resolve_stats
+      if query_hash[:stats]
+        Stats::Payload.new(@resource, @query, @unpaginated_object).generate
+      else
+        {}
+      end
+    end
+
+    def resolve
+      if @query.zero_results?
+        []
+      else
+        resolved = @resource.resolve(@object)
+        assign_serializer(resolved)
+        yield resolved if block_given?
+        if @opts[:after_resolve]
+          @opts[:after_resolve].call(resolved)
+        end
+        sideload(resolved) unless @query.sideloads.empty?
+        resolved
+      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)
+      end
+    end
+
+    def sideload(results)
+      return if results == []
+
+      concurrent = ::Graphiti.config.concurrency
+      promises = []
+
+      @query.sideloads.each_pair do |name, q|
+        sideload = @resource.class.sideload(name)
+        resolve_sideload = -> { sideload.resolve(results, q) }
+        if concurrent
+          promises << Concurrent::Promise.execute(&resolve_sideload)
+        else
+          resolve_sideload.call
+        end
+      end
+
+      if concurrent
+        # Wait for all promises to finish
+        while !promises.all? { |p| p.fulfilled? || p.rejected? }
+          sleep 0.01
+        end
+        # Re-raise the error with correct stacktrace
+        # OPTION** to avoid failing here?? if so need serializable patch
+        # to avoid loading data when association not loaded
+        if rejected = promises.find(&:rejected?)
+          raise rejected.reason
+        end
+      end
+    end
+
+    def apply_scoping(scope, opts)
+      @object = scope
+      add_scoping(nil, Graphiti::Scoping::DefaultFilter, opts)
+      add_scoping(:filter, Graphiti::Scoping::Filter, opts)
+      add_scoping(:sort, Graphiti::Scoping::Sort, opts)
+      add_scoping(:paginate, Graphiti::Scoping::Paginate, opts)
+      @object
+    end
+
+    def add_scoping(key, scoping_class, opts, default = {})
+      @object = scoping_class.new(@resource, query_hash, @object, opts).apply
+      @unpaginated_object = @object unless key == :paginate
+    end
+  end
+end

data/lib/graphiti/scoping/base.rb

@@ -0,0 +1,99 @@
+module Graphiti
+  module Scoping
+    # The interface for scoping logic (filter, paginate, etc).
+    #
+    # This class defines some common behavior, such as falling back on
+    # 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
+    #
+    # @see Scoping::DefaultFilter
+    # @see Scoping::ExtraFields
+    # @see Scoping::Filter
+    # @see Scoping::Paginate
+    # @see Scoping::Sort
+    # @see Scope#initialize
+    # @see Scope#query_hash
+    # @see Query#to_hash
+    class Base
+      attr_reader :resource, :query_hash
+
+      # @param [Resource] resource the Resource instance
+      # @param [Hash] query_hash the Query#to_hash node relevant to the current resource
+      # @param scope the base scope object to chain/modify
+      # @param [Hash] opts configuration options used by subclasses
+      def initialize(resource, query_hash, scope, opts = {})
+        @query_hash = query_hash
+        @resource   = resource
+        @scope      = scope
+        @opts       = opts
+      end
+
+      # Apply this scoping criteria.
+      # This is where we would chain on pagination, sorting, etc.
+      #
+      # If #apply? returns false, does nothing. Otherwise will apply
+      # the default logic:
+      #
+      #   # no block, run default logic via adapter
+      #   allow_filter :name
+      #
+      # Or the customized proc:
+      #
+      #   allow_filter :name do |scope, value|
+      #     scope.where("upper(name) = ?", value.upcase)
+      #   end
+      #
+      # @see #apply?
+      # @return the scope object
+      def apply
+        if apply?
+          apply_standard_or_override
+        else
+          @scope
+        end
+      end
+
+      # Should we process this scope logic?
+      #
+      # Useful for when we want to explicitly opt-out on
+      # certain requests, or avoid a default in certain contexts.
+      #
+      # @return [Boolean] if we should apply this scope logic
+      def apply?
+        true
+      end
+
+      # Defines how to call/apply the default scoping logic
+      def apply_standard_scope
+        raise 'override in subclass'
+      end
+
+      # Defines how to call/apply the custom scoping logic provided by the
+      # user.
+      def apply_custom_scope
+        raise 'override in subclass'
+      end
+
+      private
+
+      # If the user customized (by providing a block in the Resource DSL)
+      # then call the custom proc. Else, call the default proc.
+      def apply_standard_or_override
+        if apply_standard_scope?
+          @scope = apply_standard_scope
+        else
+          @scope = apply_custom_scope
+        end
+
+        @scope
+      end
+
+      # Should we apply the default proc, or a custom one?
+      def apply_standard_scope?
+        custom_scope.nil?
+      end
+    end
+  end
+end

data/lib/graphiti/scoping/default_filter.rb

@@ -0,0 +1,58 @@
+module Graphiti
+  # Default filters apply to every request, unless specifically overridden in
+  # the request.
+  #
+  # Maybe we only want to show active posts:
+  #
+  #   class PostResource < ApplicationResource
+  #     # ... code ...
+  #     default_filter :active do |scope|
+  #       scope.where(active: true)
+  #     end
+  #   end
+  #
+  # But if the user is an admin and specifically requests inactive posts:
+  #
+  #   class PostResource < ApplicationResource
+  #     # ... code ...
+  #     allow_filter :active, if: admin?
+  #
+  #     default_filter :active do |scope|
+  #       scope.where(active: true)
+  #     end
+  #   end
+  #
+  #   # Now a GET /posts?filter[active]=false will return inactive posts
+  #   # if the user is an admin.
+  #
+  # @see Resource.default_filter
+  # @see Resource.allow_filter
+  class Scoping::DefaultFilter < Scoping::Base
+    include Scoping::Filterable
+
+    # Apply the default filtering logic.
+    # Loop through each defined default filter, and apply the default
+    # proc unless an explicit override is requested
+    #
+    # @return scope the scope object we are chaining/modifying
+    def apply
+      resource.default_filters.each_pair do |name, opts|
+        next if overridden?(name)
+        @scope = opts[:filter].call(@scope, resource.context)
+      end
+
+      @scope
+    end
+
+    private
+
+    def overridden?(name)
+      if found = find_filter(name)
+        found_aliases = found[name][:aliases]
+        filter_param.keys.any? { |k| found_aliases.include?(k.to_sym) }
+      else
+        false
+      end
+    end
+  end
+end

data/lib/graphiti/scoping/extra_attributes.rb

@@ -0,0 +1,29 @@
+module Graphiti
+  class Scoping::ExtraAttributes < Scoping::Base
+    # Loop through all requested extra fields. If custom scoping
+    # logic is define for that field, run it. Otherwise, do nothing.
+    #
+    # @return the scope object we are chaining/modofying
+    def apply
+      each_extra_attribute do |callable|
+        @scope = callable.call(@scope, resource.context)
+      end
+
+      @scope
+    end
+
+    private
+
+    def each_extra_field
+      resource.extra_fields.each_pair do |name, callable|
+        if extra_fields.include?(name)
+          yield callable
+        end
+      end
+    end
+
+    def extra_fields
+      query_hash[:extra_fields][resource.type] || []
+    end
+  end
+end

data/lib/graphiti/scoping/filter.rb

@@ -0,0 +1,93 @@
+module Graphiti
+  # Apply filtering logic to the scope
+  #
+  # If the user requests to filter a field that has not been whitelisted,
+  # a +Graphiti::Errors::BadFilter+ error will be raised.
+  #
+  #   allow_filter :title # :title now whitelisted
+  #
+  # If the user requests a filter field that has been whitelisted, but
+  # does not pass the associated `+:if+ clause, +BadFilter+ will be raised.
+  #
+  #   allow_filter :title, if: :admin?
+  #
+  # This will also honor filter aliases.
+  #
+  #   # GET /posts?filter[headline]=foo will filter on title
+  #   allow_filter :title, aliases: [:headline]
+  #
+  # @see Adapters::Abstract#filter
+  # @see Adapters::ActiveRecord#filter
+  # @see Resource.allow_filter
+  class Scoping::Filter < Scoping::Base
+    include Scoping::Filterable
+
+    # Apply the filtering logic.
+    #
+    # Loop and parse all requested filters, taking into account guards and
+    # aliases. If valid, call either the default or custom filtering logic.
+    # @return the scope we are chaining/modifying
+    def apply
+      if missing_required_filters.any?
+        raise Errors::RequiredFilter.new(resource, missing_required_filters)
+      end
+
+      each_filter do |filter, operator, value|
+        @scope = filter_scope(filter, operator, value)
+      end
+
+      @scope
+    end
+
+    private
+
+    def filter_scope(filter, operator, value)
+      operator = operator.to_s.gsub('!', 'not_').to_sym
+
+      if custom_scope = filter.values.first[operator]
+        custom_scope.call(@scope, value, resource.context)
+      else
+        filter_via_adapter(filter, operator, value)
+      end
+    end
+
+    def filter_via_adapter(filter, operator, value)
+      type_name = Types.name_for(filter.values.first[:type])
+      method    = :"filter_#{type_name}_#{operator}"
+      attribute = filter.keys.first
+
+      if resource.adapter.respond_to?(method)
+        resource.adapter.send(method, @scope, attribute, value)
+      else
+        raise Errors::AdapterNotImplemented.new \
+          resource.adapter, attribute, method
+      end
+    end
+
+    def each_filter
+      filter_param.each_pair do |param_name, param_value|
+        filter = find_filter!(param_name)
+        param_value = { eq: param_value } unless param_value.is_a?(Hash)
+        value = param_value.values.first
+        operator = param_value.keys.first
+        value = param_value.values.first unless filter.values[0][:type] == :hash
+        value = value.split(',') if value.is_a?(String) && value.include?(',')
+        value = coerce_types(param_name.to_sym, value)
+        yield filter, operator, value
+      end
+    end
+
+    def coerce_types(name, value)
+      type_name = @resource.all_attributes[name][:type]
+      is_array = type_name.to_s.starts_with?('array_of') ||
+        Types[type_name][:canonical_name] == :array
+
+      if is_array
+        @resource.typecast(name, value, :filterable)
+      else
+        value = value.nil? || value.is_a?(Hash) ? [value] : Array(value)
+        value.map { |v| @resource.typecast(name, v, :filterable) }
+      end
+    end
+  end
+end

data/lib/graphiti/scoping/filterable.rb

@@ -0,0 +1,36 @@
+module Graphiti
+  # @api private
+  module Scoping::Filterable
+    # @api private
+    def find_filter(name)
+      find_filter!(name)
+    rescue Graphiti::Errors::AttributeError
+      nil
+    end
+
+    # @api private
+    def find_filter!(name)
+      resource.class.get_attr!(name, :filterable, request: true)
+      { name => resource.filters[name] }
+    end
+
+    # @api private
+    def filter_param
+      query_hash[:filter] || {}
+    end
+
+    def missing_required_filters
+      required_attributes - filter_param.keys
+    end
+
+    def required_attributes
+      resource.attributes.map do |k, v|
+        k if v[:filterable] == :required
+      end.compact
+    end
+
+    def required_filters_provided?
+      missing_required_filters.empty?
+    end
+  end
+end