graphiti 2.0.0.beta.3 → 2.0.0.beta.5

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -108,40 +108,44 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
   end
 
   def resolve(parents, query, graph_parent)
-    return future_resolve(parents, query, graph_parent).value! if Graphiti.config.concurrency
+    if Graphiti.config.concurrency
+      future_resolve(parents, query, graph_parent).value!
+    else
+      sync_resolve(parents, query, graph_parent)
+    end
+  end
 
-    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
-      next if group_name.nil? || grouper.ignore?(group_name)
+  def future_resolve(parents, query, graph_parent)
+    promises = []
+    each_resolvable_group(parents, query) do |child, group, child_query|
+      promises << child.future_resolve(group, child_query, graph_parent)
+    end
+    Concurrent::Promises.zip(*promises)
+  end
 
-      match = ->(c) { c.group_name == group_name.to_sym }
-      if (sideload = children.values.find(&match))
-        duped = remove_invalid_sideloads(sideload.resource, query)
-        sideload.resolve(group, duped, graph_parent)
-      else
-        err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
-        raise err.new(self, group_name)
-      end
+  private
+
+  def sync_resolve(parents, query, graph_parent)
+    each_resolvable_group(parents, query) do |child, group, child_query|
+      child.resolve(group, child_query, graph_parent)
     end
   end
 
-  def future_resolve(parents, query, graph_parent)
-    promises = parents.group_by(&grouper.field_name).filter_map do |(group_name, group)|
+  # Group parents by their polymorphic type and yield each group's child
+  # sideload alongside a query pruned to the sideloads that child supports.
+  def each_resolvable_group(parents, query)
+    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
       next if group_name.nil? || grouper.ignore?(group_name)
 
-      match = ->(c) { c.group_name == group_name.to_sym }
-      if (sideload = children.values.find(&match))
-        duped = remove_invalid_sideloads(sideload.resource, query)
-        sideload.future_resolve(group, duped, graph_parent)
-      else
-        err = ::Graphiti::Errors::PolymorphicSideloadChildNotFound
-        raise err.new(self, group_name)
+      child = children.values.find { |candidate| candidate.group_name == group_name.to_sym }
+      unless child
+        raise ::Graphiti::Errors::PolymorphicSideloadChildNotFound.new(self, group_name)
       end
+
+      yield child, group, remove_invalid_sideloads(child.resource, query)
     end
-    Concurrent::Promises.zip(*promises)
   end
 
-  private
-
   # We may be requesting a relationship that some subclasses support,
   # but not others. Remove anything we don't support.
   # TODO: spec to ensure this dupe logic doesn't mutate the original

data/lib/graphiti/sideload.rb

@@ -122,8 +122,25 @@ module Graphiti
       !!@polymorphic_as
     end
 
+    # False everywhere but a plain belongs_to - see
+    # Sideload::BelongsTo#linkage_from_foreign_key?.
+    def linkage_from_foreign_key?
+      false
+    end
+
+    # nil at either of the first two levels means "not specified" rather
+    # than "false".
     def always_include_resource_ids?
-      !!@always_include_resource_ids
+      return !!@always_include_resource_ids unless @always_include_resource_ids.nil?
+
+      configured = parent_resource_class&.always_include_resource_ids_by_default
+      return !!configured unless configured.nil?
+
+      default_include_resource_ids?
+    end
+
+    def default_include_resource_ids?
+      false
     end
 
     def link?
@@ -292,48 +309,19 @@ module Graphiti
       children.replace(associated) if track_associated
     end
 
-    # Synchronous counterpart to #future_resolve, used when concurrency is off.
-    # Mirrors #future_resolve but resolves inline via the synchronous
-    # Scope#resolve / #load paths (no promises). See Scope#sync_resolve_sideloads.
     def resolve(parents, query, graph_parent)
-      return future_resolve(parents, query, graph_parent).value! if Graphiti.config.concurrency
-
-      if single? && parents.length > 1
-        raise Errors::SingularSideload.new(self, parents.length)
-      end
-
-      if self.class.scope_proc
-        sideload_scope = fire_scope(parents)
-        sideload_scope = Scope.new sideload_scope,
-          resource,
-          query,
-          parent: graph_parent,
-          sideload: self,
-          sideload_parent_length: parents.length,
-          default_paginate: false
-        sideload_scope.resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
-        end
+      if Graphiti.config.concurrency
+        future_resolve(parents, query, graph_parent).value!
       else
-        load(parents, query, graph_parent)
+        sync_resolve(parents, query, graph_parent)
       end
     end
 
     def future_resolve(parents, query, graph_parent)
-      if single? && parents.length > 1
-        raise Errors::SingularSideload.new(self, parents.length)
-      end
+      assert_singular!(parents)
 
       if self.class.scope_proc
-        sideload_scope = fire_scope(parents)
-        sideload_scope = Scope.new sideload_scope,
-          resource,
-          query,
-          parent: graph_parent,
-          sideload: self,
-          sideload_parent_length: parents.length,
-          default_paginate: false
-        sideload_scope.future_resolve do |sideload_results|
+        build_sideload_scope(parents, query, graph_parent).future_resolve do |sideload_results|
           fire_assign(parents, sideload_results)
         end
       else
@@ -401,6 +389,37 @@ module Graphiti
 
     private
 
+    # Synchronous counterpart to #future_resolve, used when concurrency is off.
+    # Resolves inline via the synchronous Scope#resolve / #load paths (no
+    # promises). See Scope#sync_resolve_sideloads.
+    def sync_resolve(parents, query, graph_parent)
+      assert_singular!(parents)
+
+      if self.class.scope_proc
+        build_sideload_scope(parents, query, graph_parent).resolve do |sideload_results|
+          fire_assign(parents, sideload_results)
+        end
+      else
+        load(parents, query, graph_parent)
+      end
+    end
+
+    def assert_singular!(parents)
+      if single? && parents.length > 1
+        raise Errors::SingularSideload.new(self, parents.length)
+      end
+    end
+
+    def build_sideload_scope(parents, query, graph_parent)
+      Scope.new fire_scope(parents),
+        resource,
+        query,
+        parent: graph_parent,
+        sideload: self,
+        sideload_parent_length: parents.length,
+        default_paginate: false
+    end
+
     def future_load(parents, query, graph_parent)
       proxy = build_resource_proxy(parents, query, graph_parent)
       proxy.respond_to?(:future_resolve_data) ? proxy.future_resolve_data : Concurrent::Promises.fulfilled_future(proxy)

data/lib/graphiti/spec_helpers/errors.rb

@@ -0,0 +1,73 @@
+module Graphiti
+  module SpecHelpers
+    module Errors
+      class Base < StandardError; end
+
+      class LinksNotFound < Base
+        def initialize(name)
+          @name = name
+        end
+
+        def message
+          "Relationship with name '#{@name}' has no links!"
+        end
+      end
+
+      class NoAttribute < Base
+        def initialize(name)
+          @name = name
+        end
+
+        def message
+          "No attribute '#{@name}' in JSON response node!"
+        end
+      end
+
+      class SideloadNotFound < Base
+        def initialize(name)
+          @name = name
+        end
+
+        def message
+          "Relationship with name '#{@name}' not found!"
+        end
+      end
+
+      class NoResponse < Base
+        def message
+          "Cannot parse response - missing #response.body!"
+        end
+      end
+
+      class NoData < Base
+        def initialize(payload)
+          @payload = payload
+        end
+
+        def message
+          "Payload did not contain 'data'! Payload was:\n\n#{JSON.pretty_generate(@payload)}"
+        end
+      end
+
+      class NoSideloads < Base
+        def initialize(payload)
+          @payload = payload
+        end
+
+        def message
+          "Tried to find sideload, but the payload did not contain 'included'! Payload was:\n\n#{JSON.pretty_generate(@payload)}"
+        end
+      end
+
+      class NoMeta < Base
+        def initialize(payload)
+          @payload = payload
+        end
+
+        def message
+          "Tried to find metadata, but the payload did not contain 'meta'! Payload was:\n\n#{JSON.pretty_generate(@payload)}"
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/spec_helpers/errors_proxy.rb

@@ -0,0 +1,75 @@
+module Graphiti
+  module SpecHelpers
+    class ErrorsProxy
+      class Error
+        attr_reader :json
+
+        def initialize(json)
+          @json = json
+        end
+
+        def attribute
+          @json[:meta][:attribute]
+        end
+
+        # TODO: move to top-level code in errorable
+        def code
+          @json[:meta][:code]
+        end
+
+        def message
+          @json[:meta][:message]
+        end
+
+        def title
+          @json[:title]
+        end
+
+        def detail
+          @json[:detail]
+        end
+
+        def status
+          @json[:status]
+        end
+      end
+
+      include Enumerable
+
+      def initialize(array)
+        @errors = array.map { |e| Error.new(e) }
+      end
+
+      def [](key)
+        @errors[key]
+      end
+
+      def each(&blk)
+        @errors.each(&blk)
+      end
+
+      def length
+        count
+      end
+
+      def to_h
+        {}.tap do |hash|
+          @errors.each do |e|
+            hash[e.attribute] = e.message
+          end
+        end
+      end
+
+      def method_missing(id, *args, &blk)
+        matches = @errors.select { |e| e.attribute.to_sym == id }
+        matches.length == 1 ? matches[0] : matches
+      end
+
+      # Any name is answered: an attribute with no matching error yields an empty
+      # array rather than raising NoMethodError.
+      def respond_to_missing?(id, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/graphiti/spec_helpers/helpers.rb

@@ -0,0 +1,107 @@
+module Graphiti
+  module SpecHelpers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      def json
+        if response&.body
+          JSON.parse(response.body).with_indifferent_access
+        else
+          raise Errors::NoResponse.new
+        end
+      end
+
+      def jsonapi_data
+        @jsonapi_data ||= if _jsonapi_data.is_a?(Hash)
+          node(from: _jsonapi_data)
+        else
+          _jsonapi_data.map { |datum| node(from: datum) }
+        end
+      end
+
+      def jsonapi_included(type = nil)
+        variable = :"@jsonapi_included#{type}"
+        memo = instance_variable_get(variable)
+        return memo if memo
+
+        nodes = _jsonapi_included.map { |i| node(from: i) }
+        if type
+          nodes.select! { |n| n.jsonapi_type == type.to_s }
+        end
+        instance_variable_set(variable, nodes)
+        nodes
+      end
+
+      def jsonapi_errors
+        @jsonapi_errors ||= ErrorsProxy.new(json["errors"] || [])
+      end
+
+      def jsonapi_meta
+        @jsonapi_errors = json["meta"] || raise(Errors::NoMeta.new(json))
+      end
+
+      def jsonapi_headers
+        media_type = "application/vnd.api+json"
+        {
+          "CONTENT_TYPE" => media_type,
+          "HTTP_ACCEPT" => media_type
+        }
+      end
+
+      def jsonapi_get(url, params: {}, headers: {})
+        get url_for(url), params: params, headers: jsonapi_headers.merge(headers)
+      end
+
+      def jsonapi_post(url, payload, headers: {})
+        post url_for(url), params: payload.to_json, headers: jsonapi_headers.merge(headers)
+      end
+
+      def jsonapi_put(url, payload, headers: {})
+        put url_for(url), params: payload.to_json, headers: jsonapi_headers.merge(headers)
+      end
+
+      def jsonapi_patch(url, payload, headers: {})
+        patch url_for(url), params: payload.to_json, headers: jsonapi_headers.merge(headers)
+      end
+
+      def jsonapi_delete(url, headers: {})
+        delete url_for(url), headers: jsonapi_headers.merge(headers)
+      end
+
+      def json_datetime(value)
+        Graphiti::Types[:datetime][:read][value].as_json
+      end
+
+      def json_date(value)
+        Graphiti::Types[:date][:read][value].as_json
+      end
+
+      # @api private
+      def node(from: nil)
+        from = json if from.nil?
+        data = from.has_key?("data") ? from["data"] : from
+        hash = {}
+        hash["id"] = data["id"]
+        hash["jsonapi_type"] = data["type"]
+        hash.merge!(data["attributes"]) if data.has_key?("attributes")
+        Node.new(hash, data["relationships"], self)
+      end
+
+      private
+
+      # @api private
+      def _jsonapi_data
+        json["data"] || raise(Errors::NoData.new(json))
+      end
+
+      # @api private
+      def _jsonapi_included
+        if json.has_key?("included")
+          json["included"]
+        else
+          raise Errors::NoSideloads.new(json)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/spec_helpers/matchers.rb

@@ -0,0 +1,196 @@
+module Graphiti
+  module SpecHelpers
+    # Assertions against a resource's DSL. The schema specs cannot cover
+    # adapter-dependent options (primary key, foreign key, and so on) because
+    # the schema does not carry them; these read the resource config directly.
+    module Matchers
+      class BaseMatcher
+        GRAPHITI_OPTS = [].freeze
+        GRAPHITI_CONFIG_KEY = ""
+        EXPECTED_ACTION = ""
+
+        def description
+          "#{self.class::EXPECTED_ACTION} #{target}"
+        end
+
+        def failure_message
+          "expected that #{resource.class} would #{self.class::EXPECTED_ACTION} #{target}\n#{@opt_failures.join("\n")}"
+        end
+
+        def failure_message_when_negated
+          "expected that #{resource.class} would not #{self.class::EXPECTED_ACTION} #{target}"
+        end
+
+        def opt_failure_message(opt, expected, actual)
+          "expected that #{opt} would be #{expected}, was #{actual}"
+        end
+
+        def does_not_match?(resource)
+          !matches?(resource)
+        end
+
+        def matches?(resource)
+          @resource = resource
+
+          expected? && expected_opts?
+        end
+
+        def with_options(opts)
+          @opts = opts
+          self
+        end
+
+        private
+
+        def actual_opts
+          self.class::GRAPHITI_OPTS & opts.keys
+        end
+
+        def config
+          @config ||= resource.class.config[self.class::GRAPHITI_CONFIG_KEY][target]
+        end
+
+        def expected_opts?
+          return false unless config
+
+          actual_opts.map { |opt| assert_opt(opt) }.all?(true)
+        end
+      end
+
+      class RelationMatcher < BaseMatcher
+        GRAPHITI_OPTS = %i[primary_key foreign_key resource readable writable link single].freeze
+        GRAPHITI_CONFIG_KEY = :sideloads
+        EXPECTED_ACTION = ""
+
+        def initialize(target)
+          @target = target
+          @opts = {}
+          @opt_failures = []
+        end
+
+        private
+
+        attr_reader :target, :opts, :resource
+
+        def assert_opt(opt)
+          asserted_opt = opt == :resource ? :resource_class : opt
+          return true if config.send(asserted_opt) == opts[opt]
+
+          @opt_failures << opt_failure_message(opt, opts[opt], config.send(asserted_opt))
+          false
+        end
+
+        def expected?
+          config && config.type == relation_name
+        end
+
+        # BelongsToMatcher -> :belongs_to, matching Sideload#type.
+        def relation_name
+          self.class.name.demodulize.gsub("Matcher", "").underscore.to_sym
+        end
+      end
+
+      class BelongsToMatcher < RelationMatcher
+        EXPECTED_ACTION = "belong to"
+      end
+
+      class HasManyMatcher < RelationMatcher
+        EXPECTED_ACTION = "have many"
+      end
+
+      class HasOneMatcher < RelationMatcher
+        EXPECTED_ACTION = "have one"
+      end
+
+      class ResourceDSLMatcher < BaseMatcher
+        def initialize(target, type)
+          @target = target
+          @type = type
+          @opts = {}
+          @opt_failures = []
+        end
+
+        private
+
+        attr_reader :target, :type, :opts, :resource
+
+        def expected?
+          config && assert_type
+        end
+
+        def assert_type
+          return true if config[:type] == type
+
+          @opt_failures << opt_failure_message("type", type, config[:type])
+          false
+        end
+
+        def assert_opt(opt)
+          return true if config[opt] == opts[opt]
+
+          @opt_failures << opt_failure_message(opt, opts[opt], config[opt])
+          false
+        end
+      end
+
+      class ExposeAttributeMatcher < ResourceDSLMatcher
+        GRAPHITI_OPTS = %i[writable readable sortable filterable].freeze
+        GRAPHITI_CONFIG_KEY = :attributes
+        EXPECTED_ACTION = "expose"
+      end
+
+      class FilterAttributeMatcher < ResourceDSLMatcher
+        GRAPHITI_OPTS = %i[allow deny single required allow_nil deny_empty].freeze
+        GRAPHITI_CONFIG_KEY = :filters
+        EXPECTED_ACTION = "filter"
+      end
+
+      # @param [Symbol] relation
+      #
+      # @example expect(subject).to belong_to_resource(:user)
+      # @example expect(subject).to belong_to_resource(:user).with_options(foreign_key: :user_id, resource: UserResource)
+      # @example expect(subject).not_to belong_to_resource(:user)
+      def belong_to_resource(relation)
+        BelongsToMatcher.new(relation)
+      end
+
+      # @param [Symbol] relation
+      #
+      # @example expect(subject).to have_many_resources(:posts)
+      # @example expect(subject).to have_many_resources(:posts).with_options(foreign_key: :post_id, resource: PostResource)
+      # @example expect(subject).not_to have_many_resources(:posts)
+      def have_many_resources(relation)
+        HasManyMatcher.new(relation)
+      end
+
+      # @param [Symbol] relation
+      #
+      # @example expect(subject).to have_one_resource(:post)
+      # @example expect(subject).to have_one_resource(:post).with_options(foreign_key: :post_id, resource: PostResource)
+      # @example expect(subject).not_to have_one_resource(:post)
+      def have_one_resource(relation)
+        HasOneMatcher.new(relation)
+      end
+
+      # @param [Symbol] attribute
+      # @param [Symbol] type
+      #
+      # @example expect(subject).to expose_attribute(:name, :string)
+      # @example expect(subject).to expose_attribute(:name, :string).with_options(writable: false)
+      # @example expect(subject).not_to expose_attribute(:name, :string)
+      def expose_attribute(attribute, type)
+        ExposeAttributeMatcher.new(attribute, type)
+      end
+
+      # @param [Symbol] attribute
+      # @param [Symbol] type
+      #
+      # @example expect(subject).to filter_attribute(:name, :string)
+      # @example expect(subject).to filter_attribute(:name, :string).with_options(allow_nil: false)
+      # @example expect(subject).not_to filter_attribute(:name, :string)
+      def filter_attribute(attribute, type)
+        FilterAttributeMatcher.new(attribute, type)
+      end
+    end
+  end
+end