graphql-decorate 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e23e910653e03c46982bf8916ab3f15cde1be96a6436cabbf0271c40a11f1b4d
-  data.tar.gz: d71940ac1feabb05b64228812ad1768f8f4f288e2ff105a619ee8cd02b00ce8a
+  metadata.gz: f51b30fb5841e235310b83ab3d9b697d86b420c1a807bb0500b73dcf231d295b
+  data.tar.gz: 4c02e6130d6955d6d9fbde06a9fe45352e1bd7f5dba7ec7e1d60c9bb846242c0
 SHA512:
-  metadata.gz: 457e1cd6d2c62e5f463ccfacd8fa62f3e444c4b980d5e1d0b24b7b59aa960bcbf3c38cb0013055c793bafb3af86a5c0c2a68ae687b0c6af66de0b5b24b96d811
-  data.tar.gz: 678fb9bd85a0de6e6f0d336f2e812f91e1a326c7e3bff426159ff2bf2a83af5bc93bdf1b4ff490650f3a851f8d42b0370955d552bf57d22a47f183e8c2335462
+  metadata.gz: 2aaa588eb463291941b8c4678daaaead6479b2526d9799998889186cccece07770cded6ec469108e2b92346317ab804fed0e7fd24acb80679251b2e0cb63dc43
+  data.tar.gz: 1c2a48487fd6b82739b501968578f039c89e7769db849daf955f152b72ec2e353b43790ea159400580f0e99f8b464c7a8f7cd98e11b7bd7a818ce42df7b2299f

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/.github/workflows/ruby.yml

@@ -0,0 +1,44 @@
+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
+
+    - name: Run tests
+      run: bundle exec rake
+
+    - 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)
+        echo $completion_percentage
+        if [[ $completion_percentage != "100.00" ]]; then
+          echo "YARD documentation must be at 100%"
+          exit 2;
+        fi

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,6 @@
 # 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
@@ -59,24 +59,28 @@ 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 +89,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 +103,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 +164,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,40 @@
+# 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'
 
 Gem::Specification.new do |spec|
-  spec.name          = "graphql-decorate"
+  spec.name          = 'graphql-decorate'
   spec.version       = GraphQL::Decorate::VERSION
-  spec.authors       = ["Ben Brook"]
-  spec.email         = ["bbrook154@gmail.com"]
+  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.license       = 'MIT'
 
   # 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', '~> 10.0'
+  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

data/lib/graphql/decorate.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 require 'graphql'
 require_relative 'decorate/version'
 require_relative 'decorate/configuration'
 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/connection_wrapper'
+require_relative 'decorate/metadata'
 
 # Matching the graphql-ruby namespace
 module GraphQL

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/connection_wrapper.rb

@@ -0,0 +1,68 @@
+# 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/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/field_extension.rb

@@ -1,26 +1,44 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Decorate
     # Extension run after fields are resolved to decorate their value.
     class FieldExtension < GraphQL::Schema::FieldExtension
       # 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.
-      def after_resolve(context:, value:, **_rest)
+      # @param value [Object, GraphQL::Schema::Object, GraphQL::Pagination::Connection] 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 if value.nil?
 
-        field_context = GraphQL::Decorate::FieldContext.new(context, options)
+        resolve_decorated_value(value, object, context)
+      end
+
+      private
+
+      def resolve_decorated_value(value, parent_object, context)
+        type = extract_type(context.to_h[:current_field].type)
         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) }
+          GraphQL::Decorate::ConnectionWrapper.wrap(value, type, context)
+        elsif collection?(value)
+          value.map do |item|
+            decorate(item, type, parent_object.object, parent_object.class, context)
+          end
         else
-          decorate(value, field_context)
+          decorate(value, type, parent_object.object, parent_object.class, context)
         end
       end
 
-      private
+      def decorate(value, type, parent_object, parent_type, context)
+        undecorated_field = GraphQL::Decorate::UndecoratedField.new(value, type, parent_object, parent_type, context)
+        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
@@ -28,8 +46,12 @@ module GraphQL
         klasses
       end
 
-      def decorate(object, field_context)
-        GraphQL::Decorate::Object.new(object, field_context).decorate
+      def extract_type(field)
+        if field.respond_to?(:of_type)
+          extract_type(field.of_type)
+        else
+          field
+        end
       end
     end
   end

data/lib/graphql/decorate/field_integration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GraphQL
   module Decorate
     # Extends default field behavior and adds extension to the field if it should be decorated.
@@ -8,30 +10,8 @@ module GraphQL
       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
+        type_attributes = GraphQL::Decorate::TypeAttributes.new(field_type)
+        extension(GraphQL::Decorate::FieldExtension) if type_attributes.decoratable?
       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,31 @@
+# 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
       # 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

data/lib/graphql/decorate/undecorated_field.rb

@@ -0,0 +1,102 @@
+# 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 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)
+        @value = value
+        @type_attributes = GraphQL::Decorate::TypeAttributes.new(type)
+        @parent_value = parent_value
+        @parent_type = parent_type
+        @graphql_context = graphql_context
+        @default_metadata = { graphql: true }
+      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_attributes, :graphql_context, :parent_value, :parent_type, :default_metadata
+
+      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
+      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
+
+      def existing_scoped_metadata
+        graphql_context[:scoped_decorator_metadata] || {}
+      end
+
+      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 ||= begin
+          if type_attributes.unresolved_type?
+            GraphQL::Decorate::TypeAttributes.new(type_attributes.type.resolve_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.0'
   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.0
 platform: ruby
 authors:
 - Ben Brook
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-27 00:00:00.000000000 Z
+date: 2021-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -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
@@ -80,8 +136,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/gem-push-on-release.yml"
-- ".github/workflows/rspec.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -91,13 +148,14 @@ 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/connection_wrapper.rb
+- lib/graphql/decorate/decoration.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:
@@ -111,7 +169,7 @@ 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:
   - - ">="

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/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