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

data/lib/graphiti/spec_helpers/node.rb

@@ -0,0 +1,88 @@
+module Graphiti
+  module SpecHelpers
+    class Node
+      attr_reader :attributes, :relationships
+
+      def initialize(attributes, relationships, context)
+        @attributes = attributes.with_indifferent_access
+        @relationships = relationships.with_indifferent_access if relationships
+        @context = context
+      end
+
+      def id
+        Integer(rawid) # Only convert if using integer ids
+      rescue ArgumentError
+        rawid
+      end
+
+      def rawid
+        @attributes["id"]
+      end
+
+      def jsonapi_type
+        @attributes["jsonapi_type"]
+      end
+
+      def has_key?(key)
+        @attributes.has_key?(key)
+      end
+      alias_method :key?, :has_key?
+
+      def [](key)
+        @attributes[key] || @attributes[key.to_s]
+      end
+
+      def []=(key, val)
+        @attributes[key] = val
+      end
+
+      alias_method :to_hash, :attributes
+
+      def method_missing(id, *args, &blk)
+        if @attributes.has_key?(id)
+          @attributes[id]
+        else
+          raise Errors::NoAttribute.new(id)
+        end
+      end
+
+      def respond_to_missing?(id, include_private = false)
+        @attributes.has_key?(id) || super
+      end
+
+      def link(relationship_name, name)
+        if @relationships.has_key?(relationship_name)
+          links = @relationships[relationship_name][:links]
+          raise Errors::LinksNotFound.new(relationship_name) unless links
+          links[name]
+        else
+          raise Errors::SideloadNotFound.new(relationship_name)
+        end
+      end
+
+      def sideload(relationship_name)
+        unless @relationships.has_key?(relationship_name)
+          raise Errors::SideloadNotFound.new(relationship_name)
+        end
+        rel = @relationships[relationship_name]
+        rel = rel[:data]
+        return if rel.nil?
+        if rel.is_a?(Hash)
+          include_for(rel[:type], rel[:id])
+        else
+          rel.map { |r| include_for(r[:type], r[:id]) }
+        end
+      end
+      alias_method :sideloads, :sideload
+
+      private
+
+      def include_for(type, id)
+        data = @context.json["included"].find do |i|
+          i["type"] == type && i["id"] == id
+        end
+        @context.node(from: data)
+      end
+    end
+  end
+end

data/lib/graphiti/spec_helpers/rspec.rb

@@ -0,0 +1,148 @@
+require "rspec/core"
+require "graphiti/spec_helpers"
+
+module Graphiti
+  module SpecHelpers
+    class ContextProxy < OpenStruct
+      def initialize(proxied, *args)
+        @__proxied = proxied
+        super(*args)
+      end
+
+      # variables defined in the rspec context should remain lazy
+      def current_user
+        super || __proxied_current_user
+      end
+
+      def params
+        super || __proxied_params
+      end
+
+      private
+
+      def __proxied_current_user
+        @__proxied.current_user if @__proxied.respond_to?(:current_user)
+      end
+
+      def __proxied_params
+        @__proxied.params if @__proxied.respond_to?(:params)
+      end
+    end
+  end
+end
+
+# Registered under both names. The graphiti-prefixed name is canonical. The bare
+# one is kept for suites that include it explicitly, and carries no `type:`
+# metadata so a `type: :resource` group does not pick the context up twice.
+resource_testing = proc do
+  let(:resource) { described_class }
+  let(:params) { {} }
+
+  around do |e|
+    original = Graphiti::Resource.validate_endpoints
+    Graphiti::Resource.validate_endpoints = false
+
+    Graphiti.with_context graphiti_context do
+      e.run
+    end
+  ensure
+    Graphiti::Resource.validate_endpoints = original
+  end
+
+  def graphiti_context
+    @graphiti_context ||= Graphiti::SpecHelpers::ContextProxy.new(self)
+  end
+
+  # If you need to set context:
+  #
+  # Graphiti.with_context my_context, {} do
+  #   render
+  # end
+  def render(runtime_options = {})
+    json = proxy.to_jsonapi(runtime_options)
+    response.body = json
+    json
+  end
+
+  def proxy
+    @proxy ||= begin
+      args = [params]
+      args << base_scope if defined?(base_scope)
+      resource.all(*args)
+    end
+  end
+
+  def records
+    proxy.data
+  end
+
+  def response
+    @response ||= OpenStruct.new
+  end
+end
+
+remote_api = proc do
+  # Fake request headers
+  around do |e|
+    ctx = OpenStruct.new \
+      request: OpenStruct.new(headers: OpenStruct.new)
+    Graphiti.with_context(ctx) { e.run }
+  end
+
+  def mock_api(url, json, call_count = 1)
+    api_response = double(body: json.to_json)
+    expect(Faraday).to receive(:get)
+      .with(url, anything, anything)
+      .exactly(call_count).times
+      .and_return(api_response)
+  end
+end
+
+# Was a top-level constant, and reopening it to add context methods was a way
+# suites customised graphiti_context. Remove in 3.0.
+GraphitiContextProxy = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+  "GraphitiContextProxy",
+  "Graphiti::SpecHelpers::ContextProxy",
+  Graphiti::DEPRECATOR
+)
+
+::RSpec.shared_context("graphiti resource testing", type: :resource, &resource_testing)
+::RSpec.shared_context("resource testing", &resource_testing)
+
+::RSpec.shared_context("graphiti remote api", &remote_api)
+::RSpec.shared_context("remote api", &remote_api)
+
+module Graphiti
+  module SpecHelpers
+    module RSpec
+      def self.included(klass)
+        klass.send(:include, Graphiti::SpecHelpers)
+
+        ::RSpec.configure do |rspec|
+          rspec.include_context "graphiti resource testing", type: :resource
+          rspec.include Graphiti::SpecHelpers::Matchers, type: :resource
+        end
+      end
+
+      def self.schema!(resources = nil)
+        ::RSpec.describe "Graphiti Schema" do
+          it "generates a backwards-compatible schema" do
+            message = <<~MSG
+              Found backwards-incompatibilities in schema! Run with FORCE_SCHEMA=true to ignore.
+
+              Incompatibilities:
+
+            MSG
+
+            errors = Graphiti::Schema.generate!(resources)
+            errors.each do |e|
+              message << "#{e}\n"
+            end
+
+            expect(errors.empty?).to eq(true), message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/spec_helpers.rb

@@ -0,0 +1,54 @@
+# Merged in from the standalone graphiti_spec_helpers gem, retired as of
+# Graphiti 2.0. The GraphitiSpecHelpers namespace and the
+# "graphiti_spec_helpers/rspec" require path are kept verbatim so existing spec
+# suites need no changes beyond dropping the gem from their Gemfile.
+require "json"
+require "active_support/core_ext/string"
+require "active_support/core_ext/hash"
+require "graphiti"
+
+require "graphiti/spec_helpers/helpers"
+require "graphiti/spec_helpers/node"
+require "graphiti/spec_helpers/errors_proxy"
+require "graphiti/spec_helpers/errors"
+require "graphiti/spec_helpers/matchers"
+
+module Graphiti
+  module SpecHelpers
+    def self.included(klass)
+      klass.send(:include, Helpers)
+    end
+
+    class TestRunner < ::Graphiti::Runner
+      def current_user
+        nil
+      end
+    end
+
+    module Sugar
+      def d
+        jsonapi_data
+      end
+
+      def included(type = nil)
+        jsonapi_included(type)
+      end
+
+      def errors
+        jsonapi_errors
+      end
+
+      def dt(*args)
+        json_datetime(*args)
+      end
+
+      def datetime(*args)
+        json_datetime(*args)
+      end
+
+      def date(*args)
+        json_date(*args)
+      end
+    end
+  end
+end

data/lib/graphiti/util/include_params.rb

@@ -7,9 +7,9 @@ module Graphiti
         #
         #   GET /posts?include=comments.author
         #
-        # But our resource had this code:
+        # But the controller had this code:
         #
-        #   sideload_allowlist({ index: [:comments] })
+        #   self.sideload_allowlist = {index: [:comments]}
         #
         # We should drop the 'author' sideload from the request.
         #

data/lib/graphiti/util/serializer_relationships.rb

@@ -19,7 +19,14 @@ module Graphiti
       private
 
       def apply?(sideload)
-        @serializer.relationship_blocks[sideload.name].nil?
+        return true if @serializer.relationship_blocks[sideload.name].nil?
+
+        # A subclass inherits its parent's relationship blocks, each closed
+        # over the parent's sideload. Redeclaring the relationship has to
+        # replace that block or the override never reaches the payload.
+        # Anything not generated here was written by hand, so leave it.
+        applied = @serializer.relationship_sideloads[sideload.name]
+        !applied.nil? && !applied.equal?(sideload)
       end
     end
 
@@ -32,6 +39,10 @@ module Graphiti
 
       def apply
         sideload = @sideload
+        # Reassign rather than mutate: ancestors share the hash by reference
+        # until a subclass writes to it.
+        @serializer.relationship_sideloads =
+          @serializer.relationship_sideloads.merge(@sideload.name => @sideload)
         @serializer.relationship(@sideload.name, if: -> { sideload.readable? }, &block)
       end
 
@@ -53,9 +64,25 @@ module Graphiti
         proc do
           data { instance_eval(&data_proc_ref) }
 
-          # include relationship links for belongs_to relationships
-          # https://github.com/graphiti-api/graphiti/issues/167
-          linkage always: sideload_ref.always_include_resource_ids?
+          # An included relationship is already loaded, and a customized
+          # sideload can resolve it to something the foreign key alone would
+          # not predict, so the loaded records win. Only the un-included case
+          # is worth short-circuiting.
+          if sideload_ref.linkage_from_foreign_key? &&
+              !self_ref.send(:included_anywhere?, @proxy.query.include_hash, sideload_ref.name)
+            linkage always: sideload_ref.always_include_resource_ids? do
+              foreign_key = @object.public_send(sideload_ref.foreign_key)
+
+              unless foreign_key.nil?
+                {
+                  type: sideload_ref.resource.type,
+                  id: foreign_key.to_s
+                }
+              end
+            end
+          else
+            linkage always: sideload_ref.always_include_resource_ids?
+          end
 
           if link_ref
             if @proxy.query.links?
@@ -69,6 +96,15 @@ module Graphiti
         end
       end
 
+      # A relationship nested under another one is still loaded and can still
+      # be narrowed by a deep filter, so the foreign key is not a safe
+      # stand-in for what the request actually returns.
+      def included_anywhere?(include_hash, name)
+        include_hash.any? do |key, nested|
+          key == name || included_anywhere?(nested, name)
+        end
+      end
+
       def data_proc
         sideload_ref = @sideload
         ->(_) {
@@ -85,7 +121,7 @@ module Graphiti
       end
 
       def eagerly_validate_links?
-        # TODO: Maybe handle this in graphiti-rails
+        # TODO: Maybe handle this in the Rails integration
         if defined?(::Rails) && (app = ::Rails.application)
           app.config.eager_load
         else

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "2.0.0.beta.3"
+  VERSION = "2.0.0.beta.5"
 end

data/lib/graphiti-rails.rb

@@ -0,0 +1,11 @@
+# Deprecated entry point. The graphiti-rails gem was absorbed into graphiti in
+# 2.0, and its integration loads automatically whenever Rails is defined, so
+# this require is no longer needed. It is kept so an explicit
+# `require "graphiti-rails"` left over from 1.x does not raise. Remove in 3.0.
+require "graphiti"
+require "graphiti/rails"
+
+Graphiti::DEPRECATOR.warn(
+  'require "graphiti-rails" is no longer needed. graphiti-rails is part of graphiti as of 2.0, ' \
+  "and the Rails integration is loaded for you when Rails is present."
+)

data/lib/graphiti.rb

@@ -3,6 +3,12 @@ require "forwardable"
 require "uri"
 require "ostruct" unless defined?(::OpenStruct)
 
+# The umbrella require, not just the core_ext files below: Graphiti.broadcast
+# calls ActiveSupport::Notifications.instrument, which reaches for
+# ActiveSupport::IsolatedExecutionState. That constant is autoloaded here and
+# nowhere else, so without this a non-Rails app raises NameError on the first
+# render unless something else happened to load ActiveSupport for us.
+require "active_support"
 require "active_support/version"
 require "active_support/deprecation"
 require "active_support/deprecator" if ::ActiveSupport.version >= Gem::Version.new("7.1")
@@ -14,12 +20,34 @@ require "active_support/concern"
 require "active_support/time"
 
 require "dry-types"
-require "graphiti_errors"
 
 require "jsonapi/serializable"
 
+# These gems are merged into graphiti as of 2.0, but their 1.x/0.x releases
+# still resolve against graphiti 2.x. Leaving one installed is never harmless:
+# graphiti_spec_helpers and graphiti-rails ship files that collide with ours
+# (lib/graphiti_spec_helpers.rb, lib/graphiti/rails.rb), so which copy a require
+# picks up comes down to load path order, and graphiti_errors installs a second,
+# competing exception handler on any controller that includes it. Fail loudly
+# rather than let either happen quietly. Checked here because graphiti is loaded
+# either way, whichever copy wins.
+{
+  "graphiti_spec_helpers" => 'The "graphiti_spec_helpers/rspec" require and the GraphitiSpecHelpers namespace are unchanged.',
+  "graphiti-rails" => 'Graphiti::Rails and its config.graphiti options are unchanged. Drop the "graphiti-rails" require if you have one.',
+  "graphiti_errors" => "Exception handling now goes through rescue_registry. Remove `include GraphitiErrors` from your controllers — Graphiti registers its own handlers, and you can add yours with `register_exception`."
+}.each do |gem_name, guidance|
+  next unless Gem.loaded_specs.key?(gem_name)
+
+  raise <<~MSG
+    #{gem_name} is merged into graphiti as of 2.0 and is no longer published
+    separately. Remove it from your Gemfile.
+
+    #{guidance}
+  MSG
+end
+
 module Graphiti
-  DEPRECATOR = ActiveSupport::Deprecation.new("2.0", "Graphiti")
+  DEPRECATOR = ActiveSupport::Deprecation.new("3.0", "Graphiti")
 
   # @api private
   def self.context
@@ -203,6 +231,10 @@ require "graphiti/query"
 require "graphiti/debugger"
 require "graphiti/util/cache_debug"
 require "graphiti/util/uri_decoder"
+require "graphiti/error_serializers/validation"
+require "graphiti/error_serializers/invalid_request"
+require "graphiti/error_serializers/conflict_request"
+require "graphiti/error_serializers/deprecated_constants"
 
 if defined?(ActiveRecord)
   require "graphiti/adapters/active_record"
@@ -210,14 +242,6 @@ end
 
 if defined?(Rails)
   require "graphiti/rails"
-  require "graphiti/responders"
-
-  # graphiti-rails has own Railtie
-  begin
-    require "graphiti-rails"
-  rescue LoadError
-    require "graphiti/railtie"
-  end
 end
 
 require "graphiti/runner"

data/lib/graphiti_errors.rb

@@ -0,0 +1,11 @@
+# Deprecated entry point. graphiti_errors was absorbed into graphiti in 2.0 and
+# graphiti required it for you in 1.x, so an explicit require left in an
+# initializer or spec_helper would otherwise raise LoadError. Only the
+# serializers survived. See graphiti/error_serializers/deprecated_constants.rb.
+# Remove in 3.0.
+require "graphiti"
+
+Graphiti::DEPRECATOR.warn(
+  'require "graphiti_errors" is no longer needed. graphiti_errors is part of graphiti as of 2.0, ' \
+  "and its exception handling is replaced by rescue_registry."
+)

data/lib/graphiti_spec_helpers/rspec.rb

@@ -0,0 +1,3 @@
+# Deprecated entry point. See graphiti_spec_helpers.rb. Remove in 3.0.
+require "graphiti/spec_helpers/rspec"
+require "graphiti_spec_helpers"

data/lib/graphiti_spec_helpers.rb

@@ -0,0 +1,11 @@
+# Deprecated entry point. The spec helpers moved under Graphiti::SpecHelpers
+# when the graphiti_spec_helpers gem was absorbed into graphiti in 2.0. This
+# keeps `require "graphiti_spec_helpers"` and the old constant working.
+# Remove in 3.0.
+require "graphiti/spec_helpers"
+
+GraphitiSpecHelpers = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+  "GraphitiSpecHelpers",
+  "Graphiti::SpecHelpers",
+  Graphiti::DEPRECATOR
+)

data/lib/tasks/graphiti.rake

@@ -0,0 +1,29 @@
+require "graphiti/rails/rake_helpers"
+
+namespace :graphiti do
+  helpers = Graphiti::Rails::RakeHelpers
+
+  desc "Execute request without web server."
+  task :request, [:path, :debug] => [:environment] do |_, args|
+    helpers.setup_rails!
+    Graphiti.logger = Graphiti.stdout_logger
+    Graphiti::Debugger.preserve = true
+    require "pp"
+    path, debug = args[:path], args[:debug]
+    puts "Graphiti Request: #{path}"
+    json = helpers.make_request(path, debug)
+    pp json
+    Graphiti::Debugger.flush if debug
+  end
+
+  desc "Execute benchmark without web server."
+  task :benchmark, [:path, :requests] => [:environment] do |_, args|
+    helpers.setup_rails!
+    took = Benchmark.ms {
+      args[:requests].to_i.times do
+        helpers.make_request(args[:path])
+      end
+    }
+    puts "Took: #{(took / args[:requests].to_f).round(2)}ms"
+  end
+end