graphql-rails-resolver 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eac8d006df6f747647df533f2606819a2b6e304a
-  data.tar.gz: c2d7486872ecc83c143fd1654f369ab8fc58045e
+  metadata.gz: daaae82f72286352c8b15b9c04ebe0f29cdb5c7d
+  data.tar.gz: 8d6d288781cbe6643e005a7d618f174f96324833
 SHA512:
-  metadata.gz: de1cd692a89ecf230ede5977aecf4e36a6ad5be227354643228d139c620f6e281547a8d259560a80e6016c3a3cbb6db8b3bf0bd691963d3ae71cb997eff14d91
-  data.tar.gz: a5de48a5fb24727abd8f92f39fb3946f9e913aa8ca2116d6ecff9bc107e3110f1568f4d07398d550f5a7fa5e211e9ebb7d4c829ccb2ba4068b2dc0a667753f4f
+  metadata.gz: a1d3162e913409721fb111794ec0cc2d325957852d126513123945683d97ab220fc16475ae391feea818014d02604f9e91a35fda4c8b12025f01e9c99adc4e78
+  data.tar.gz: 2388a47c80fcfd9440322c14355587d6dd546866b95b9ff3402e3761c47faf459a517086c56470c3a850353f116736154bd75e22ce325cdff59f009021c9f152

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# GraphQL::Rails::Resolver
+## CHANGELOG
+
+### Version 0.1.3
+Added `resolve_scope` for resolving model scopes.
+Fixed `resolve_where` not being called and reworked class inheritance.
+
+
+### Version 0.1.2
+Initial release. Took a couple tries to figure out how to import to a new namespace on an existing gem.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Cole Turner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,11 +1,11 @@
-# ActiveResolver (graphql-rails-resolver)
-A utility for ease graphql-ruby integration into a Rails project. ActiveResolver offers a declarative approach to resolving Field arguments in a Rails environment.
+# GraphQL::Rails::Resolver (graphql-rails-resolver)
+A utility to ease graphql-ruby integration into a Rails project. This resolver offers a declarative approach to resolving Field arguments in a Rails environment.
 
-# How it works:
-`ActiveResolver.rb` serves as a base class for your GraphQL Ruby schema. When a resolver inherits from this base class, you can easily map arguments in a GraphQL Field to an attribute on an ActiveRecord model or a custom method.
+# How it works
+`GraphQL::Rails::Resolver` serves as a base class for your GraphQL Ruby schema. When a resolver inherits from this base class, you can easily map arguments in a GraphQL Field to an attribute on an ActiveRecord model or a custom method.
 
 ## Why?
-**tl;dr; Active Resolvers achieves three goals: maintainable query type, code re-use, and a declarative integration with Ruby on Rails.**
+**tl;dr; To achieves three goals: maintainable query type, code re-use, and a declarative integration with Ruby on Rails.**
 
 Take for example the following Rails model:
 
@@ -16,6 +16,7 @@ class Post < ApplicationRecord
 
   scope :is_public, -> { where(is_public: true) }
   scope :is_private, -> { where(is_public: false) }
+  scope :featured, -> (value) { where(created_at: value) }
 
   def tags
      ["hello", "world"]
@@ -28,11 +29,11 @@ The standard implementation for resolving a `Post` is as follows:
 
 ```
 field :post, PostType do
-    argument :is_public, types.Boolean, default_value: true
- 	resolve -> (obj, args, ctx) {
-    	post.is_public if args[:is_public]
-        post.is_private unless args[:is_public]
-    }
+  argument :is_public, types.Boolean, default_value: true
+  resolve -> (obj, args, ctx) {
+    post.is_public if args[:is_public]
+    post.is_private unless args[:is_public]
+  }
 end
 ```
 
@@ -43,8 +44,8 @@ Using the pattern from this article, our Field becomes much simpler:
 **/app/graph/types/query_type.rb**
 ```
 field :post, PostType do
-    argument :is_public, types.Boolean, default_value: true
- 	resolve Resolvers::Post.new
+  argument :is_public, types.Boolean, default_value: true
+  resolve Resolvers::Post.new
 end
 ```
 
@@ -65,19 +66,27 @@ module Resolvers
   end
 end
 ```
-This solution addresses code re-use, however this series of conditionals do not allow you to resolve more than one argument, and it may become difficult to maintain this imperative approach.
+This solution addresses code re-use, but these series of conditionals do not allow you to resolve more than one argument, and it may become difficult to maintain this imperative approach.
 
 
-## Hello Active Resolver:
+## Hello "Active" Resolver
 **Out with imperative, in with declarative.**
 
-Take the Resolver from the previous example. Using `ActiveResolver`, we inherit and use declarations for arguments and how they will be resolved. These declarations will be mapped to the attributes on the resolved model.
+To begin, we install the gem by adding it to our `Gemfile`:
+
+`
+gem 'graphql-rails-resolver'
+`
+
+This will load a class by the name of `GraphQL::Rails::Resolver`
+
+Take the Resolver from the previous example. Using `GraphQL::Rails::Resolver`, we inherit and use declarations for arguments and how they will be resolved. These declarations will be mapped to the attributes on the resolved model.
 
 ```
 # Class name must match the Rails model name exactly.
 
-class Post < GraphQL::Rails::ActiveResolver
-  # ID argument is resolved within ActiveResolver
+class Post < GraphQL::Rails::Resolver
+  # ID argument is resolved in base class
 
   # Resolve :is_public to a class method
   resolve_method :is_public
@@ -87,6 +96,18 @@ class Post < GraphQL::Rails::ActiveResolver
   resolve_where :created_at
   resolve_where :updated_at
 
+  # Resolve :featured argument with default test: if argument `featured` is present
+  resolve_scope :featured
+
+  # Same resolution as the line above, but send the value to the scope function
+  resolve_scope :featured, :with_value => true
+
+  # Resolve :featured scope if it passes custom argument test
+  resolve_scope :featured, -> (value) { value == :today }
+
+  # Resolve :is_public argument with a different scope name
+  resolve_scope :is_public, -> (value) { value != true }, :scope_name => :is_private
+
   def is_public(value)
     @result.is_public if value
     @result.is_private unless value
@@ -95,13 +116,15 @@ class Post < GraphQL::Rails::ActiveResolver
 end
 ```
 
-In the example above, there are two declarations:
+In the example above, there are three declarations:
 
 `resolve_where` is a declarative approach using `ActiveRecord.where` to resolve arguments.
 
-`resolve_method` is an imperative approach that's useful for using Model scopes or custom resolution.
+`resolve_scope` is an declarative way to call scopes on a model where a custom test for the argument can be specified with a closure.
+- Use `with_value` to send the argument value to the scope closure.
+- Use `scope_name` to map an argument to a scope by another name.
 
-[Help make scopes declarative!](#making-scopes-declarative)
+`resolve_method` is an imperative approach that allows completely custom resolution.
 
 
 
@@ -115,7 +138,7 @@ end
 ```
 
 ### Find Model by ID
-Every Active Resolver includes the ability to resolve a model by ID. Using the following method, by default the resolver will find a model by **NodeIdentification.from_global_id(value)** or **Model.where(:id => value)**. This means a model can be resolved by Global ID or Integer ID.
+`GraphQL::Rails::Resolver` includes the ability to resolve a model by ID. Using the following method, by default the resolver will find a model by **NodeIdentification.from_global_id(value)** or **Model.where(:id => value)**. This means a model can be resolved by Global ID or Integer ID.
 ```
 def lookup_id(value)
   ...
@@ -123,8 +146,8 @@ end
 ```
 
 
-### Override Default Resolution
-The default behavior is to use `Model.all` to seed the resolution. This seed can be changed by providing a block or lambda to the class instance:
+### Override Default Scope
+The default behavior is to use `Model.all` to scope the resolution. This scope can be changed by providing a block or lambda to the class instance:
 ```
 Resolvers::Post.new(Proc.new {
 	::Post.where(:created_at => ...)
@@ -133,22 +156,8 @@ Resolvers::Post.new(Proc.new {
 
 
 # Needs Help
-I wanted to release this utility for the hopes of sparking interest in Rails integration with `graphql-ruby`.
-
-If you wish to contribute to this project, any pull request is warmly welcomed. If time permits, I will continue to update this project to achieve the following:
-
-### [Making Scopes Declarative](#making-scopes-declarative):
-For first release, scopes can only be resolved using `resolve_method`. The goal for further development is to stop using `resolve_method` and adapt other methods to facilitate resolution.
-
-The current syntax planned for scope resolution is as follows, where the argument is passed to the scope:
-
-```
-resolve_scope :is_public, -> (args) { args[:is_public] == true }
-resolve_scope :is_private, -> (args) { args[:is_public] == false }
-```
-
-
+I wanted to release this utility for the hopes of sparking interest in Rails integration with `graphql-ruby`. If you wish to contribute to this project, any pull request is warmly welcomed. 
 
 # Credits
-- Cole Turner ([@colepatrickturner](/colepatrickturner))
-- Peter Salanki ([@salanki](/salanki))
+- Cole Turner ([@colepatrickturner](https://github.com/colepatrickturner))
+- Peter Salanki ([@salanki](https://github.com/salanki))

data/lib/graphql/rails/resolver.rb

@@ -1,7 +1,9 @@
 module GraphQL
   module Rails
     class Resolver
-      VERSION = '0.1.2'
+      VERSION = '0.1.3'
+
+      attr_accessor :resolvers
 
       def initialize(callable=nil)
         unless callable.nil?
@@ -12,7 +14,7 @@ module GraphQL
         @obj = nil
         @args = nil
         @ctx = nil
-        @resolvers = {}
+        @resolvers = self.class.resolvers
       end
 
       def call(obj, args, ctx)
@@ -29,7 +31,7 @@ module GraphQL
 
         @resolvers.each do |field,method|
           if args.key? field
-            method
+            @result = method.call(@result, args[field])
           end
         end
 
@@ -75,28 +77,6 @@ module GraphQL
         "::#{self.class.name.demodulize}".constantize
       end
 
-      def self.resolve(field, method)
-        self.class_eval do
-          @resolvers[field] = method
-        end
-      end
-
-      def self.resolve_where(field)
-        self.class_eval do
-          resolve(field, Proc.new {
-            @result = @result.where(field, @args[field])
-          })
-        end
-      end
-
-      def self.resolve_method(field)
-        self.class_eval do
-          resolve(field, Proc.new {
-            send(field, @args[field])
-          })
-        end
-      end
-
       def lookup_id(value)
         if is_global_id(value)
           type_name, id = NodeIdentification.from_global_id(value)
@@ -112,7 +92,49 @@ module GraphQL
         end
       end
 
+      class << self
+
+        def resolvers
+          @resolvers ||= {}
+          @resolvers
+        end
+
+        def resolve(field, method)
+          @resolvers ||= {}
+          @resolvers[field] = method
+        end
+
+        def resolve_where(field)
+          resolve(field, lambda { |obj, value|
+            where = {}
+            where[field] = value
+
+            obj.where(where)
+          })
+        end
+
+        def resolve_scope(field, test=nil, scope_name: nil, with_value: false)
+          test = lambda { |value| value.present? } if test.nil?
+          scope_name = field if scope_name.nil?
 
+          resolve(field, lambda { |obj, value|
+            args = []
+            args.push(value) if with_value
+
+            if test.call(value)
+              obj.send(scope_name, *args)
+            else
+              obj
+            end
+          })
+        end
+
+        def resolve_method(field)
+          resolve(field, lambda { |obj, value|
+            obj.send(field, value)
+          })
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-resolver
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Cole Turner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-22 00:00:00.000000000 Z
+date: 2016-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -44,6 +44,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
 - README.md
 - lib/graphql/rails.rb
 - lib/graphql/rails/resolver.rb