graphql-decorate 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f51b30fb5841e235310b83ab3d9b697d86b420c1a807bb0500b73dcf231d295b
-  data.tar.gz: 4c02e6130d6955d6d9fbde06a9fe45352e1bd7f5dba7ec7e1d60c9bb846242c0
+  metadata.gz: 87a8fe01c943ec96814efe0e1eff084e8a1a06d07ddfb25bdc957b7b9d7e1359
+  data.tar.gz: 834c64c23ce5db962159773e82f10ad7130322cffba0ef340a3dbd244b0ec8e4
 SHA512:
-  metadata.gz: 2aaa588eb463291941b8c4678daaaead6479b2526d9799998889186cccece07770cded6ec469108e2b92346317ab804fed0e7fd24acb80679251b2e0cb63dc43
-  data.tar.gz: 1c2a48487fd6b82739b501968578f039c89e7769db849daf955f152b72ec2e353b43790ea159400580f0e99f8b464c7a8f7cd98e11b7bd7a818ce42df7b2299f
+  metadata.gz: 536f14a8113cd9c166667260b743ef2443b1b845a2293d4fc1b006fd9818d819cd90439c6fd186d10c7ba0657eb6bd67840053160a65045edff94a69ace61db4
+  data.tar.gz: a083fe5519d3d5c980e01e9aa72f8e9c4f18d05c0130032a617933aba15410a9b32d7ef0b29dae8445dec018b68fc963b1964bb2534f06481594ab7759587498

data/.github/workflows/{ruby.yml → ci.yml}

@@ -1,4 +1,4 @@
-name: Ruby
+name: CI
 
 on:
   push:
@@ -7,7 +7,7 @@ on:
     branches: [ master ]
 
 jobs:
-  test:
+  ci:
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -28,12 +28,6 @@ jobs:
     - name: Run RuboCop
       run: bundle exec rubocop
 
-    - name: Upload coverage results
-      uses: actions/upload-artifact@master
-      with:
-        name: coverage-report
-        path: coverage
-
     - name: Check documentation completion
       run: |
         completion_percentage=$(bundle exec yard | tee /dev/stdout  | tail -1 | cut -d'%' -f1 | xargs)

data/README.md

@@ -1,3 +1,6 @@
+[![Gem Version](https://badge.fury.io/rb/graphql-decorate.svg)](https://badge.fury.io/rb/graphql-decorate)
+![CI](https://github.com/TrueCar/graphql-decorate/actions/workflows/ci.yml/badge.svg)
+
 # GraphQL Decorate
 
 `graphql-decorate` adds an easy-to-use interface for decorating types in [`graphql-ruby`](https://github.com/rmosolgo/graphql-ruby). It lets 
@@ -19,16 +22,19 @@ Or install it yourself as:
 
     $ gem install graphql-decorate
 
-Once the gem is installed, you need to add the integrations to your base type and field classes. 
+Once the gem is installed, you need to add the plugin to  your schema and the integration into 
+your base object class. 
 ```ruby
-class BaseType < GraphQL::Schema::Object
-  extend GraphQL::Decorate::ObjectIntegration
+class Schema < GraphQL::Schema
+  use GraphQL::Decorate
 end
 
-class BaseField < GraphQL::Schema::Field
-  include GraphQL::Decorate::FieldIntegration
+class BaseObject < GraphQL::Schema::Object
+  include GraphQL::Decorate::ObjectIntegration
 end
 ```
+Note that `use GraphQL::Decorate` must be included in the schema _after_ `query` and `mutation` 
+so that the fields to be extended are initialized first.
 
 ## Usage
 
@@ -48,7 +54,7 @@ class RectangleDecorator < BaseDecorator
   end
 end
 
-class Rectangle < GraphQL::Schema::Object
+class Rectangle < BaseObject
   decorate_with RectangleDecorator
   
   field :area, Int, null: false

data/graphql-decorate.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'graphql', '>= 1.3', '< 2'
 
   spec.add_development_dependency 'bundler', '>= 2'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', ' >= 1.11.0 '
   spec.add_development_dependency 'rubocop-rspec', '2.2.0'

data/lib/graphql/decorate.rb

@@ -3,19 +3,20 @@
 require 'graphql'
 require_relative 'decorate/version'
 require_relative 'decorate/configuration'
+require_relative 'decorate/extract_type'
 require_relative 'decorate/object_integration'
-require_relative 'decorate/field_integration'
 require_relative 'decorate/field_extension'
 require_relative 'decorate/decoration'
 require_relative 'decorate/type_attributes'
 require_relative 'decorate/undecorated_field'
-require_relative 'decorate/connection_wrapper'
 require_relative 'decorate/metadata'
 
 # Matching the graphql-ruby namespace
 module GraphQL
   # Entry point for graphql-decorate. Handles configuration.
   module Decorate
+    extend ExtractType
+
     # @return [Configuration] Returns a new instance of GraphQL::Decorate::Configuration.
     def self.configuration
       @configuration ||= Configuration.new
@@ -30,5 +31,19 @@ module GraphQL
     def self.reset_configuration!
       @configuration = Configuration.new
     end
+
+    # @param schema_defn [GraphQL::Schema] Current schema class
+    # @return [nil]
+    def self.use(schema_defn)
+      schema_defn.to_graphql.types.each do |_name, type|
+        next unless type.respond_to?(:fields)
+
+        type.fields.each do |_name, field|
+          field_type = extract_type(field.type_class.type)
+          type_attributes = GraphQL::Decorate::TypeAttributes.new(field_type)
+          field.type_class.extension(GraphQL::Decorate::FieldExtension) if type_attributes.decoratable?
+        end
+      end
+    end
   end
 end

data/lib/graphql/decorate/extract_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Allows extraction of a type class from a particular field.
+module ExtractType
+  private
+
+  def extract_type(field)
+    if field.respond_to?(:of_type)
+      extract_type(field.of_type)
+    else
+      field
+    end
+  end
+end

data/lib/graphql/decorate/field_extension.rb

@@ -4,35 +4,35 @@ module GraphQL
   module Decorate
     # Extension run after fields are resolved to decorate their value.
     class FieldExtension < GraphQL::Schema::FieldExtension
+      include ExtractType
+
       # Extension to be called after lazy loading.
       # @param context [GraphQL::Query::Context] The current GraphQL query context.
-      # @param value [Object, GraphQL::Schema::Object, GraphQL::Pagination::Connection] The object being decorated. Can
+      # @param value [Object, Array, GraphQL::Schema::Object] The object being decorated. Can
       #   be a schema object if the field hasn't been resolved yet or a connection.
-      # @param object [Object] Object the field is being resolved on.
-      # @return [Object, GraphQL::Decorate::ConnectionWrapper] Decorated object.
-      def after_resolve(context:, value:, object:, **_rest)
+      # @return [Object] Decorated object.
+      def after_resolve(context:, value:, **_rest)
         return if value.nil?
 
-        resolve_decorated_value(value, object, context)
+        resolve_decorated_value(value, context)
       end
 
       private
 
-      def resolve_decorated_value(value, parent_object, context)
+      def resolve_decorated_value(value, context)
         type = extract_type(context.to_h[:current_field].type)
-        if value.is_a?(GraphQL::Pagination::Connection)
-          GraphQL::Decorate::ConnectionWrapper.wrap(value, type, context)
-        elsif collection?(value)
-          value.map do |item|
-            decorate(item, type, parent_object.object, parent_object.class, context)
+
+        if collection?(value)
+          value.each_with_index.map do |item, index|
+            decorate(item, type, context, index)
           end
         else
-          decorate(value, type, parent_object.object, parent_object.class, context)
+          decorate(value, type, context)
         end
       end
 
-      def decorate(value, type, parent_object, parent_type, context)
-        undecorated_field = GraphQL::Decorate::UndecoratedField.new(value, type, parent_object, parent_type, context)
+      def decorate(value, type, context, index = nil)
+        undecorated_field = GraphQL::Decorate::UndecoratedField.new(value, type, context, index)
         GraphQL::Decorate::Decoration.decorate(undecorated_field)
       end
 
@@ -45,14 +45,6 @@ module GraphQL
         klasses << ::ActiveRecord::Relation if defined?(ActiveRecord::Relation)
         klasses
       end
-
-      def extract_type(field)
-        if field.respond_to?(:of_type)
-          extract_type(field.of_type)
-        else
-          field
-        end
-      end
     end
   end
 end

data/lib/graphql/decorate/object_integration.rb

@@ -4,6 +4,12 @@ module GraphQL
   module Decorate
     # Extends GraphQL::Schema::Object classes with methods to set the desired decorator class and context.
     module ObjectIntegration
+      # @param base [Class] Base class the module is being included in
+      # @return [nil]
+      def self.included(base)
+        base.extend(self)
+      end
+
       # Decorate the type with a decorator class.
       # @param klass [Class] Class the object should be decorated with.
       def decorate_with(klass = nil, &block)

data/lib/graphql/decorate/type_attributes.rb

@@ -39,7 +39,7 @@ module GraphQL
 
       # @return [Boolean] True if type is not yet resolved, false if it is resolved
       def unresolved_type?
-        type.respond_to?(:resolve_type)
+        type.respond_to?(:kind) && [GraphQL::TypeKinds::INTERFACE, GraphQL::TypeKinds::UNION].include?(type.kind)
       end
 
       # @return [Boolean] True if type is resolved, false if it is not resolved
@@ -47,19 +47,10 @@ module GraphQL
         !unresolved_type?
       end
 
-      # @return [Boolean] True if type is a connection, false if it is resolved
-      def connection?
-        resolved_type? && type.respond_to?(:node_type)
-      end
-
       private
 
       def get_attribute(name)
-        if connection?
-          type.node_type.respond_to?(name) && type.node_type.public_send(name)
-        elsif resolved_type?
-          type.respond_to?(name) ? type.public_send(name) : nil
-        end
+        type.respond_to?(name) ? type.public_send(name) : nil
       end
     end
   end

data/lib/graphql/decorate/undecorated_field.rb

@@ -9,16 +9,15 @@ module GraphQL
 
       # @param value [Object] Value to be decorated
       # @param type [GraphQL::Schema::Object] Type class of value to be decorated
-      # @param parent_value [Object] Value of the parent field
-      # @param parent_type [GraphQL::Schema::Object] Type class of the parent field
       # @param graphql_context [GraphQL::Query::Context] Current query graphql_context
-      def initialize(value, type, parent_value, parent_type, graphql_context)
+      def initialize(value, type, graphql_context, index = nil)
         @value = value
+        @type = type
         @type_attributes = GraphQL::Decorate::TypeAttributes.new(type)
-        @parent_value = parent_value
-        @parent_type = parent_type
         @graphql_context = graphql_context
         @default_metadata = { graphql: true }
+        @path = graphql_context[:current_path].dup
+        @path << index if index
       end
 
       # @return [Class] Decorator class for the current field
@@ -37,34 +36,44 @@ module GraphQL
 
       private
 
-      attr_reader :type_attributes, :graphql_context, :parent_value, :parent_type, :default_metadata
+      attr_reader :type, :type_attributes, :graphql_context, :default_metadata, :path
 
       def unscoped_metadata
         unscoped_metadata_proc&.call(value, graphql_context) || {}
       end
 
       def scoped_metadata
-        merged_scoped_metadata = existing_scoped_metadata.merge(new_scoped_metadata)
-        graphql_context.scoped_set!(:scoped_decorator_metadata, merged_scoped_metadata)
-        merged_scoped_metadata
+        insert_scoped_metadata(new_scoped_metadata)
       end
 
       def new_scoped_metadata
-        scoped_metadata = scoped_metadata_proc&.call(value, graphql_context) || {}
-        parent_scoped_metadata.merge(scoped_metadata)
-      end
-
-      def parent_scoped_metadata
-        parent_type_attributes.decorator_metadata&.scoped_proc&.call(parent_value, graphql_context) || {}
-      end
-
-      def parent_type_attributes
-        GraphQL::Decorate::TypeAttributes.new(parent_type)
-      end
+        scoped_metadata_proc&.call(value, graphql_context) || {}
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def insert_scoped_metadata(metadata)
+        # Save metadata at each level in the path of the current execution.
+        # If a field's direct parent does not have metadata then it will
+        # use the next highest metadata in the tree that matches its path.
+        scoped_metadata = graphql_context[:scoped_decorator_metadata] ||= {}
+        prev_value = {}
+
+        path[0...-1].each do |step|
+          # Write the parent's metadata to the child if it doesn't already exist
+          scoped_metadata[step] = { value: prev_value, children: {} } unless scoped_metadata[step]
+          # Update the next parent's metadata to include anything at the current level
+          prev_value = prev_value.merge(scoped_metadata[step][:value])
+          # Move to the child fields and repeat
+          scoped_metadata = scoped_metadata[step][:children]
+        end
 
-      def existing_scoped_metadata
-        graphql_context[:scoped_decorator_metadata] || {}
+        # The last step in the path is the current field, merge in new metadata from
+        # the field itself and return it.
+        merged_metadata = { value: prev_value.merge(metadata), children: {} }
+        scoped_metadata[path[-1]] = merged_metadata
+        merged_metadata[:value]
       end
+      # rubocop:enable Metrics/AbcSize
 
       def unscoped_metadata_proc
         type_attributes.decorator_metadata&.unscoped_proc || resolve_unscoped_proc
@@ -93,7 +102,11 @@ module GraphQL
       def resolved_type_attributes
         @resolved_type_attributes ||= begin
           if type_attributes.unresolved_type?
-            GraphQL::Decorate::TypeAttributes.new(type_attributes.type.resolve_type(value, graphql_context))
+            if type.respond_to?(:resolve_type)
+              GraphQL::Decorate::TypeAttributes.new(type.resolve_type(value, graphql_context))
+            else
+              graphql_context.schema.resolve_type(type, value, graphql_context)
+            end
           end
         end
       end

data/lib/graphql/decorate/version.rb

@@ -3,6 +3,6 @@
 module GraphQL
   module Decorate
     # Current version number
-    VERSION = '1.0.0'
+    VERSION = '1.0.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-decorate
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Ben Brook
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-10 00:00:00.000000000 Z
+date: 2021-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -48,16 +48,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -135,8 +135,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".github/workflows/gem-push-on-release.yml"
-- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - Gemfile
@@ -148,10 +148,9 @@ files:
 - graphql-decorate.gemspec
 - lib/graphql/decorate.rb
 - lib/graphql/decorate/configuration.rb
-- lib/graphql/decorate/connection_wrapper.rb
 - lib/graphql/decorate/decoration.rb
+- lib/graphql/decorate/extract_type.rb
 - lib/graphql/decorate/field_extension.rb
-- lib/graphql/decorate/field_integration.rb
 - lib/graphql/decorate/metadata.rb
 - lib/graphql/decorate/object_integration.rb
 - lib/graphql/decorate/type_attributes.rb

data/lib/graphql/decorate/connection_wrapper.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Decorate
-    # Wraps a GraphQL::Pagination::ConnectionWrapper object to decorate values after pagination is applied.
-    class ConnectionWrapper
-      # @param connection [GraphQL::Pagination::Connection] ConnectionWrapper being decorated
-      # @param node_type [GraphQL::Schema::Object] Type class of the connection's node
-      # @param context [GraphQL::Query::Context] Current query context
-      def self.wrap(connection, node_type, context)
-        @connection_class = connection.class
-        new(connection, node_type, context)
-      end
-
-      # @return [GraphQL::Pagination::Connection] ConnectionWrapper being decorated
-      attr_reader :connection
-
-      # @param connection [GraphQL::Pagination::Connection] ConnectionWrapper being decorated
-      # # @param node_type [GraphQL::Schema::Object] Type class of the connection's node
-      # @param context [GraphQL::Query::Context] Current query context
-      def initialize(connection, node_type, context)
-        @connection = connection
-        @node_type = node_type
-        @context = context
-      end
-
-      # @return [Array] Decorated nodes after pagination is applied
-      def nodes
-        nodes = @connection.nodes
-        nodes.map do |node|
-          unresolved_field = GraphQL::Decorate::UndecoratedField.new(node, node_type, connection.parent,
-                                                                     connection.field.owner, context)
-          GraphQL::Decorate::Decoration.decorate(unresolved_field)
-        end
-      end
-
-      # @see nodes
-      # @return [Array] Decorated nodes after pagination is applied
-      def edge_nodes
-        nodes
-      end
-
-      class << self
-        private
-
-        def method_missing(symbol, *args, &block)
-          @connection_class.send(symbol, *args, &block) || super
-        end
-
-        def respond_to_missing?(method, include_private = false)
-          @connection_class.respond_to?(method, include_private)
-        end
-      end
-
-      private
-
-      attr_reader :node_type, :context
-
-      def method_missing(symbol, *args, &block)
-        @connection.send(symbol, *args, &block) || super
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        @connection.respond_to?(method, include_private)
-      end
-    end
-  end
-end

data/lib/graphql/decorate/field_integration.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Decorate
-    # Extends default field behavior and adds extension to the field if it should be decorated.
-    module FieldIntegration
-      # Overridden field initializer
-      # @param type [GraphQL::Schema::Object] The type to add the extension to.
-      # @return [Void]
-      def initialize(type:, **rest, &block)
-        super
-        field_type = [type].flatten(1).first
-        type_attributes = GraphQL::Decorate::TypeAttributes.new(field_type)
-        extension(GraphQL::Decorate::FieldExtension) if type_attributes.decoratable?
-      end
-    end
-  end
-end