graphql-decorate 0.2.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e23e910653e03c46982bf8916ab3f15cde1be96a6436cabbf0271c40a11f1b4d
-  data.tar.gz: d71940ac1feabb05b64228812ad1768f8f4f288e2ff105a619ee8cd02b00ce8a
+  metadata.gz: ac0949a542979b4218036dae55013d1b148cda15cfafdab0d741aa23d882d289
+  data.tar.gz: ac03a2c2c2d554fadd4a7b1ad489d572954c84d7efb77f8afe301c3e8f5909ab
 SHA512:
-  metadata.gz: 457e1cd6d2c62e5f463ccfacd8fa62f3e444c4b980d5e1d0b24b7b59aa960bcbf3c38cb0013055c793bafb3af86a5c0c2a68ae687b0c6af66de0b5b24b96d811
-  data.tar.gz: 678fb9bd85a0de6e6f0d336f2e812f91e1a326c7e3bff426159ff2bf2a83af5bc93bdf1b4ff490650f3a851f8d42b0370955d552bf57d22a47f183e8c2335462
+  metadata.gz: 4646f9ea8f791e8ae56163ee8f1ff67849a697365eed6fc5ac9d3ef4327933d6d650cb2aef6cf8160ebea76826de0152d13c9c0b5719da5bdb02e012d9371587
+  data.tar.gz: 02e3384f30868f20d490db4dc3481c77bc94f1ce1e3ad446c15a9bb63a3825fd98d7712341452ed532e4a794379503a0e9d4db518080c521d980579337373fd3

data/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+
+    - name: Run tests
+      run: bundle exec rake
+
+    - name: Run RuboCop
+      run: bundle exec rubocop
+
+    - name: Check documentation completion
+      run: |
+        completion_percentage=$(bundle exec yard | tee /dev/stdout  | tail -1 | cut -d'%' -f1 | xargs)
+        echo $completion_percentage
+        if [[ $completion_percentage != "100.00" ]]; then
+          echo "YARD documentation must be at 100%"
+          exit 2;
+        fi

data/.github/workflows/gem-push-on-release.yml

@@ -11,10 +11,11 @@ jobs:
 
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.6.x
+        ruby-version: 2.6
+        bundler-cache: true
 
     - name: Verify version number matches
       run: |

data/.rubocop.yml

@@ -0,0 +1,14 @@
+require:
+  rubocop-rspec
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.6
+  SuggestExtensions: false
+RSpec/FilePath:
+  CustomTransform:
+    GraphQL: graphql
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+RSpec/MessageSpies:
+  EnforcedStyle: receive

data/Gemfile

@@ -1,6 +1,8 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in graphql-decorate.gemspec
 gemspec

data/README.md

@@ -1,6 +1,9 @@
+[![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`. It lets 
+`graphql-decorate` adds an easy-to-use interface for decorating types in [`graphql-ruby`](https://github.com/rmosolgo/graphql-ruby). It lets 
 you move logic out of your type files and keep them declarative. 
 
 ## Installation
@@ -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 RectangleType < BaseObject
   decorate_with RectangleDecorator
   
   field :area, Int, null: false
@@ -59,24 +65,27 @@ In this example, the `Rectangle` type is being decorated with a `RectangleDecora
 `RectangleDecorator`. All of the methods on the decorator are accessible on the type.
 
 ### Decorators
-By default, `graphql-decorate` is set up to work with Draper-style decorators. These decorators 
+By default, `graphql-decorate` is set up to work with [`draper`](https://github.com/drapergem/draper) style decorators. These decorators 
 provide a `decorate` method that wraps the original object and returns an instance of the 
-decorator. They can also take in an additional context hash.
+decorator. They can also take in additional metadata.
 ```ruby
-RectangleDecorator.decorate(rectangle, context)
+RectangleDecorator.decorate(rectangle, context: metadata)
 ```
 If you are using a different decorator pattern then you can override this default behavior in 
 the configuration.
 ```ruby
 GraphQL::Decorate.configure do |config|
-  config.decorate do |decorator_class, object, _context|
+  config.decorate do |decorator_class, object, _metadata|
     decorator_class.decorate_differently(object)
   end
 end
 ```
 
 ### Types
-Three methods are made available on your type classes
+Two methods are made available on your type classes: `decorate_with` and `decorate_metadata`. 
+Every method that yields the underlying object will also yield the current GraphQL `context`. 
+If decoration depends on some context in the current query then you can access it when the field is resolved.
+
 #### decorate_with
 `decorate_with` accepts a decorator class that will decorate every instance of your type.
 ```ruby
@@ -85,12 +94,11 @@ class Rectangle < GraphQL::Schema::Object
 end
 ```
 
-#### decorate_when
-`decorate_when` accepts a block which yields the underlying object. If you have multiple 
+`decorate_with` optionally accepts a block which yields the underlying object. If you have multiple 
 possible decorator classes you can return the one intended for the underling object.
 ```ruby
 class Rectangle < GraphQL::Schema::Object
-  decorate_when do |object|
+  decorate_with do |object, _graphql_context|
     if object.length == object.width
       SquareDecorator
     else
@@ -100,30 +108,50 @@ class Rectangle < GraphQL::Schema::Object
 end
 ```
 
-#### decorator_context
-`decorator_context` accepts a block which yields the underlying object. If your decorator pattern 
-allows additional context being passed into the decorators, you can define it here.
+#### decorate_metadata
+If your decorator pattern allows additional metadata to be passed into the decorators, you can 
+define it here. By default every metadata hash will contain `{ graphql: true }`. This is 
+useful if your decorator logic needs to diverge when used in a GraphQL context. Ideally your 
+decorators are agnostic to where they are being used, but it is available if needed.
+
+`decorate_metadata` yields a `GraphQL::Decorate::Metadata` metadata instance. It responds to two 
+methods: `unscoped` and `scoped`. `unscoped` sets metadata for a resolved field. `scoped` sets 
+metadata for a resolved field and all of its child fields. `unscoped` and `scoped` are expected 
+to return `Hash`s.
+
 ```ruby
 class Rectangle < GraphQL::Schema::Object
-  decorator_context do |object|
-    {
-      name: object.name
-    }
+  decorate_metadata do |metadata| 
+    metadata.unscoped do |object, _graphql_context| 
+      { 
+        name: object.name
+      }
+    end
+   
+    metadata.scoped do |object, _graphql_context|
+      {
+        inside_rectangle: true
+      }
+    end
   end
 end
 ```
-`RectangleDecorator` will be initialized with a context of `{ name: <object_name> }`. 
+`RectangleDecorator` will be initialized with metadata `{ name: <object_name>,
+inside_rectangle: true, graphql: true }`. All child fields of `Rectangle` will be initialized 
+with metadata `{ inside_rectangle: true, graphql: true }`.
 
 #### Combinations
-You can mix and match these methods to suit your needs. Note that if `decorate_with` and 
-`decorate_when` are both provided that `decorate_with` will take precedence.
+You can mix and match these methods to suit your needs. Note that if `unscoped` and 
+`scoped` are both provided for metadata that `scoped` will override any shared keys.
 ```ruby
 class Rectangle < GraphQL::Schema::Object
   decorate_with RectangleDecorator
-  decorator_context do |object|
-    {
-      name: object.name
-    }
+  decorate_metadata do |metadata|
+    metadata.scoped do |object, _graphql_context|
+      {
+        name: object.name
+      } 
+    end
   end
 end
 ```
@@ -141,8 +169,11 @@ end
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to 
+run the tests. You can also run `bin/console` for an interactive prompt that will allow you to 
+experiment.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the 
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "graphql/decorate"
+require 'bundler/setup'
+require 'graphql/decorate'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "graphql/decorate"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/graphql-decorate.gemspec

@@ -1,30 +1,45 @@
+# frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "graphql/decorate/version"
+require 'graphql/decorate/version'
 
+# rubocop:disable Metrics/BlockLength
 Gem::Specification.new do |spec|
-  spec.name          = "graphql-decorate"
-  spec.version       = GraphQL::Decorate::VERSION
-  spec.authors       = ["Ben Brook"]
-  spec.email         = ["bbrook154@gmail.com"]
+  spec.name = 'graphql-decorate'
+  spec.version = GraphQL::Decorate::VERSION
+  spec.authors = ['Ben Brook']
+  spec.email = ['bbrook154@gmail.com']
 
-  spec.summary       = 'A decorator integration for the GraphQL gem'
-  spec.homepage      = 'https://www.github.com/TrueCar/graphql-decorate'
-  spec.license       = "MIT"
+  spec.summary = 'A decorator integration for the GraphQL gem'
+  spec.homepage = 'https://www.github.com/TrueCar/graphql-decorate'
+  spec.license = 'MIT'
+  spec.metadata = {
+    'rubygems_mfa_required' => 'true'
+  }
 
   # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  # The `git ls-files -z` loads the files in the RubyGem that have been added
+  # into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency "graphql", ">= 1.3", "< 2"
+  spec.required_ruby_version = '>= 2.6.0'
 
-  spec.add_development_dependency "bundler", ">= 2"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_runtime_dependency 'graphql', '>= 1.3', '< 2'
+
+  spec.add_development_dependency 'bundler', '>= 2'
+  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'
+  spec.add_development_dependency 'simplecov', '~> 0.21.2'
+  spec.add_development_dependency 'yard', '~> 0.9.26'
 end
+# rubocop:enable Metrics/BlockLength

data/lib/graphql/decorate/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GraphQL
   module Decorate
     # Allows overriding default decoration and custom collection class behavior.
@@ -9,8 +11,8 @@ module GraphQL
       attr_accessor :custom_collection_classes
 
       def initialize
-        @evaluate_decorator = lambda do |decorator_class, object, context|
-          decorator_class.decorate(object, context: context)
+        @evaluate_decorator = lambda do |decorator_class, object, metadata|
+          decorator_class.decorate(object, context: metadata)
         end
         @custom_collection_classes = []
       end

data/lib/graphql/decorate/decoration.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Decorate
+    # Handles decorating an value at runtime given its current field.
+    class Decoration
+      # Resolve the undecorated_field.value with decoration.
+      # @param undecorated_field [GraphQL::Decorate::UndecoratedField]
+      # @return [Object] Decorated undecorated_field.value if possible, otherwise the original undecorated_field.value.
+      def self.decorate(undecorated_field)
+        new(undecorated_field).decorate
+      end
+
+      # @param undecorated_field [GraphQL::Decorate::UndecoratedField]
+      def initialize(undecorated_field)
+        @undecorated_field = undecorated_field
+      end
+
+      # @return [Object] Decorated undecorated_field.value if possible, otherwise the original undecorated_field.value.
+      def decorate
+        if undecorated_field.decorator_class
+          GraphQL::Decorate.configuration.evaluate_decorator.call(undecorated_field.decorator_class,
+                                                                  undecorated_field.value, undecorated_field.metadata)
+        else
+          undecorated_field.value
+        end
+      end
+
+      private
+
+      attr_reader :undecorated_field
+    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

@@ -1,36 +1,50 @@
 # frozen_string_literal: true
+
 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] The object being decorated. Can be a schema object if the field hasn't been resolved yet.
-      # @return [::Object, GraphQL::Decorate::Connection] Decorated object.
+      # @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.
+      # @return [Object] Decorated object.
       def after_resolve(context:, value:, **_rest)
         return if value.nil?
 
-        field_context = GraphQL::Decorate::FieldContext.new(context, options)
-        if value.is_a?(GraphQL::Pagination::Connection)
-          GraphQL::Decorate::Connection.new(value, field_context)
-        elsif collection_classes.any? { |c| value.is_a?(c) }
-          value.map { |item| decorate(item, field_context) }
+        resolve_decorated_value(value, context)
+      end
+
+      private
+
+      def resolve_decorated_value(value, context)
+        type = extract_type(context.to_h[:current_field].type)
+
+        if collection?(value)
+          value.each_with_index.map do |item, index|
+            decorate(item, type, context, index)
+          end
         else
-          decorate(value, field_context)
+          decorate(value, type, context)
         end
       end
 
-      private
+      def decorate(value, type, context, index = nil)
+        undecorated_field = GraphQL::Decorate::UndecoratedField.new(value, type, context, index)
+        GraphQL::Decorate::Decoration.decorate(undecorated_field)
+      end
+
+      def collection?(value)
+        collection_classes.any? { |c| value.is_a?(c) }
+      end
 
       def collection_classes
         klasses = [Array] + GraphQL::Decorate.configuration.custom_collection_classes
         klasses << ::ActiveRecord::Relation if defined?(ActiveRecord::Relation)
         klasses
       end
-
-      def decorate(object, field_context)
-        GraphQL::Decorate::Object.new(object, field_context).decorate
-      end
     end
   end
 end

data/lib/graphql/decorate/metadata.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Decorate
+    # Contains methods to evaluate different types of metadata
+    class Metadata
+      # @return [Proc]
+      attr_reader :unscoped_proc
+
+      # @return [Proc]
+      attr_reader :scoped_proc
+
+      def initialize
+        @unscoped_proc = nil
+        @scoped_proc = nil
+      end
+
+      # @yield [object, graphql_context] Evaluate metadata for a single resolved field
+      def unscoped(&block)
+        @unscoped_proc = block
+      end
+
+      # @yield [object, graphql_context] Evaluate metadata for a resolved field and all child fields
+      def scoped(&block)
+        @scoped_proc = block
+      end
+    end
+  end
+end

data/lib/graphql/decorate/object_integration.rb

@@ -1,41 +1,37 @@
+# frozen_string_literal: true
+
 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)
+      def decorate_with(klass = nil, &block)
         @decorator_class = klass
-      end
-
-      # Dynamically choose the decorator class based on the underlying object.
-      # @yield [object] Gives the underlying object to the block.
-      # @return [Proc] Proc to evaluate decorator class. Proc should return a decorator class.
-      def decorate_when(&block)
         @decorator_evaluator = block
       end
 
       # Pass additional data to the decorator context (if supported).
       # @yield [object] Gives the underlying object to the block.
       # @return [Proc] Proc to evaluate decorator context. Proc should return Hash.
-      def decorator_context(&block)
-        @decorator_context_evaluator = block
+      def decorate_metadata
+        @decorator_metadata ||= GraphQL::Decorate::Metadata.new
+        yield(@decorator_metadata)
       end
 
       # @return [Class, nil] Gets the currently set decorator class.
-      def decorator_class
-        @decorator_class
-      end
+      attr_reader :decorator_class
 
       # @return [Proc, nil] Gets the currently set decorator evaluator.
-      def decorator_evaluator
-        @decorator_evaluator
-      end
+      attr_reader :decorator_evaluator
 
-      # @return [Proc, nil] Gets the currently set decorator context evaluator.
-      def decorator_context_evaluator
-        @decorator_context_evaluator
-      end
+      attr_reader :decorator_metadata
     end
   end
 end

data/lib/graphql/decorate/type_attributes.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Decorate
     # Extracts configured decorator attributes from a GraphQL::Schema::Object type.
@@ -11,6 +12,11 @@ module GraphQL
         @type = type
       end
 
+      # @return [Boolean] True if the type can be decorated, false otherwise
+      def decoratable?
+        !!(decorator_class || decorator_evaluator || unresolved_type?)
+      end
+
       # @return [Class, nil] Decorator class for the type if available
       def decorator_class
         get_attribute(:decorator_class)
@@ -21,9 +27,9 @@ module GraphQL
         get_attribute(:decorator_evaluator)
       end
 
-      # @return [Proc, nil] Decorator context evaluator for the type if available
-      def decorator_context_evaluator
-        get_attribute(:decorator_context_evaluator)
+      # @return [Proc, nil] Decorator metadata evaluator for the type if available
+      def decorator_metadata
+        get_attribute(:decorator_metadata)
       end
 
       # @return [GraphQL::Schema::Object, nil] Decorator evaluator for the type if available
@@ -33,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
@@ -41,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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Decorate
+    # Wraps current value, parents, and graphql_context and extracts relevant decoration data to resolve the field.
+    class UndecoratedField
+      # @return [Object] Value to be decorated
+      attr_reader :value
+
+      # @param value [Object] Value to be decorated
+      # @param type [GraphQL::Schema::Object] Type class of value to be decorated
+      # @param graphql_context [GraphQL::Query::Context] Current query graphql_context
+      def initialize(value, type, graphql_context, index = nil)
+        @value = value
+        @type = type
+        @type_attributes = GraphQL::Decorate::TypeAttributes.new(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
+      def decorator_class
+        resolved_class = type_attributes.decorator_class || resolve_decorator_class
+        return resolved_class if resolved_class
+
+        class_evaluator = type_attributes.decorator_evaluator || resolve_decorator_evaluator
+        class_evaluator&.call(value, graphql_context)
+      end
+
+      # @return [Hash] Metadata to be provided to a decorator for the current field
+      def metadata
+        default_metadata.merge(unscoped_metadata, scoped_metadata)
+      end
+
+      private
+
+      attr_reader :type, :type_attributes, :graphql_context, :default_metadata, :path
+
+      def unscoped_metadata
+        unscoped_metadata_proc&.call(value, graphql_context) || {}
+      end
+
+      def scoped_metadata
+        insert_scoped_metadata(new_scoped_metadata)
+      end
+
+      def new_scoped_metadata
+        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
+
+        # 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
+      end
+
+      def scoped_metadata_proc
+        type_attributes.decorator_metadata&.scoped_proc || resolve_scoped_proc
+      end
+
+      def resolve_decorator_class
+        resolved_type_attributes&.decorator_class
+      end
+
+      def resolve_decorator_evaluator
+        resolved_type_attributes&.decorator_evaluator
+      end
+
+      def resolve_unscoped_proc
+        resolved_type_attributes&.decorator_metadata&.unscoped_proc
+      end
+
+      def resolve_scoped_proc
+        resolved_type_attributes&.decorator_metadata&.scoped_proc
+      end
+
+      def resolved_type_attributes
+        @resolved_type_attributes ||= if type_attributes.unresolved_type?
+                                        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
+  end
+end

data/lib/graphql/decorate/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module GraphQL
   module Decorate
     # Current version number
-    VERSION = "0.2.1"
+    VERSION = '1.0.2'
   end
 end

data/lib/graphql/decorate.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 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/object'
+require_relative 'decorate/decoration'
 require_relative 'decorate/type_attributes'
-require_relative 'decorate/field_context'
-require_relative 'decorate/connection'
+require_relative 'decorate/undecorated_field'
+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
@@ -27,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.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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-decorate
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Ben Brook
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-27 00:00:00.000000000 Z
+date: 2022-04-25 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
@@ -72,6 +72,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.26
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.26
 description: 
 email:
 - bbrook154@gmail.com
@@ -79,9 +135,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".github/workflows/gem-push-on-release.yml"
-- ".github/workflows/rspec.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -91,18 +148,19 @@ files:
 - graphql-decorate.gemspec
 - lib/graphql/decorate.rb
 - lib/graphql/decorate/configuration.rb
-- lib/graphql/decorate/connection.rb
-- lib/graphql/decorate/field_context.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/object.rb
+- lib/graphql/decorate/metadata.rb
 - lib/graphql/decorate/object_integration.rb
 - lib/graphql/decorate/type_attributes.rb
+- lib/graphql/decorate/undecorated_field.rb
 - lib/graphql/decorate/version.rb
 homepage: https://www.github.com/TrueCar/graphql-decorate
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -111,14 +169,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: A decorator integration for the GraphQL gem

data/.github/workflows/rspec.yml

@@ -1,32 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
-# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
-
-name: Ruby
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  test:
-
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby-version }}
-        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-    - name: Run tests
-      run: bundle exec rake

data/lib/graphql/decorate/connection.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Decorate
-    # Wraps a GraphQL::Pagination::Connection object to decorate values after pagination is applied.
-    class Connection
-      # @return [GraphQL::Pagination::Connection] Connection being decorated
-      attr_reader :connection
-
-      # @return [GraphQL::Decorate::FieldContext] Current field context
-      attr_reader :field_context
-
-      def initialize(connection, field_context)
-        @connection = connection
-        @field_context = field_context
-      end
-
-      # @return [Array] Decorated nodes after pagination is applied
-      def nodes
-        nodes = @connection.nodes
-        nodes.map { |node| GraphQL::Decorate::Object.new(node, field_context).decorate }
-      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)
-        end
-
-        def respond_to_missing?(method, include_private = false)
-          @connection.class.respond_to_missing(method, include_private)
-        end
-      end
-
-      private
-
-      def method_missing(symbol, *args, &block)
-        @connection.send(symbol, *args, &block)
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        @connection.respond_to_missing(method, include_private)
-      end
-    end
-  end
-end

data/lib/graphql/decorate/field_context.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Decorate
-    # Wraps current GraphQL::Query::Context and options provided to a field for portability.
-    class FieldContext
-      # @return [GraphQL::Query::Context] Current GraphQL query context
-      attr_reader :context
-
-      # @return [Hash] Options provided to the field being decorated
-      attr_reader :options
-
-      def initialize(context, options)
-        @context = context
-        @options = options
-      end
-    end
-  end
-end

data/lib/graphql/decorate/field_integration.rb

@@ -1,38 +0,0 @@
-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
-        extension_options = get_extension_options(field_type)
-        extend_with_decorator(extension_options) if extension_options
-      end
-
-      private
-
-      def get_extension_options(type)
-        type_attributes = GraphQL::Decorate::TypeAttributes.new(type)
-        return unless type_attributes.decorator_class
-
-        {
-          decorator_class: type_attributes.decorator_class,
-          decorator_evaluator: type_attributes.decorator_evaluator,
-          decorator_context_evaluator: type_attributes.decorator_context_evaluator,
-          unresolved_type: type_attributes.unresolved_type
-        }
-      end
-
-      def extend_with_decorator(options)
-        extension(GraphQL::Decorate::FieldExtension, options)
-        # ext = GraphQL::Decorate::FieldExtension.new(field: self, options: options)
-        # @extensions = @extensions.dup
-        # @extensions.unshift(ext)
-        # @extensions.freeze
-      end
-    end
-  end
-end

data/lib/graphql/decorate/object.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Decorate
-    # Handles decorating an object given its current field context.
-    class Object
-      # @param object [Object] Object being decorated.
-      # @param field_context [GraphQL::Decorate::FieldContext] Current GraphQL field context and options.
-      def initialize(object, field_context)
-        @object = object
-        @field_context = field_context
-        @default_decorator_context = { graphql: true }
-      end
-
-      # Resolve the object with decoration.
-      # @return [Object] Decorated object if possible, otherwise the original object.
-      def decorate
-        if decorator_class
-          GraphQL::Decorate.configuration.evaluate_decorator.call(decorator_class, object, decorator_context)
-        else
-          object
-        end
-      end
-
-      private
-
-      attr_reader :object, :field_context, :default_decorator_context
-
-      def decorator_class
-        if field_context.options[:decorator_class]
-          field_context.options[:decorator_class]
-        elsif field_context.options[:decorator_evaluator]
-          field_context.options[:decorator_evaluator].call(object)
-        else
-          resolve_decorator_class
-        end
-      end
-
-      def decorator_context_evaluator
-        field_context.options[:decorator_context_evaluator] || resolve_decorator_context_evaluator
-      end
-
-      private
-
-      def evaluate_decoration_context
-        decorator_context_evaluator ? decorator_context_evaluator.call(object) : {}
-      end
-
-      def decorator_context
-        evaluate_decoration_context.merge(default_decorator_context)
-      end
-
-      def resolve_decorator_class
-        type = resolve_type
-        if type.respond_to?(:decorator_class) && type.decorator_class
-          type.decorator_class
-        end
-      end
-
-      def resolve_decorator_context_evaluator
-        type = resolve_type
-        if type.respond_to?(:decorator_context_evaluator) && type.decorator_context_evaluator
-          type.decorator_context_evaluator
-        end
-      end
-
-      def resolve_type
-        field_context.options[:unresolved_type]&.resolve_type(object, field_context.context)
-      end
-    end
-  end
-end