graphql-rails-resolver 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: daaae82f72286352c8b15b9c04ebe0f29cdb5c7d
-  data.tar.gz: 8d6d288781cbe6643e005a7d618f174f96324833
+  metadata.gz: c3bd5d1d617b2c9a98b5c934e6338d121a3e1b9d
+  data.tar.gz: 52dcc208c579b92a5af7cb0b25e63ff756b48443
 SHA512:
-  metadata.gz: a1d3162e913409721fb111794ec0cc2d325957852d126513123945683d97ab220fc16475ae391feea818014d02604f9e91a35fda4c8b12025f01e9c99adc4e78
-  data.tar.gz: 2388a47c80fcfd9440322c14355587d6dd546866b95b9ff3402e3761c47faf459a517086c56470c3a850353f116736154bd75e22ce325cdff59f009021c9f152
+  metadata.gz: 7d6067d452c52d4b22492c36dd2317363cb73be52d0d9043dc446a5f756acdfe6221361aa39604e8319af882671525799c7b0f98076a72c26447d11e80789297
+  data.tar.gz: 61ec192ce50cfc125187eab6d212613f5036853fbf12376ec22e88f31e2d350b28bdd63d9a23d844968f956f979fa743d8a72826effacc4497f280d52196dce9

data/CHANGELOG.md

@@ -1,6 +1,10 @@
 # GraphQL::Rails::Resolver
 ## CHANGELOG
 
+### Version 0.1.4
+Added `resolve` with parameters
+Deprecates `resolve_where` and `resolve_scope`
+
 ### Version 0.1.3
 Added `resolve_scope` for resolving model scopes.
 Fixed `resolve_where` not being called and reworked class inheritance.

data/README.md

@@ -88,43 +88,44 @@ Take the Resolver from the previous example. Using `GraphQL::Rails::Resolver`, w
 class Post < GraphQL::Rails::Resolver
   # ID argument is resolved in base class
 
-  # Resolve :is_public to a class method
-  resolve_method :is_public
-
   # Resolve :title, :created_at, :updated_at to Post.where() arguments
-  resolve_where :title
-  resolve_where :created_at
-  resolve_where :updated_at
+  resolve :title
+  resolve :createdAt, :where => :created_at
+  resolve :updatedAt, :where => :updated_at
 
   # Resolve :featured argument with default test: if argument `featured` is present
-  resolve_scope :featured
+  resolve :featured, :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 => :featured, :with_value => true
 
-  # Resolve :featured scope if it passes custom argument test
-  resolve_scope :featured, -> (value) { value == :today }
+  # Resolve :featured scope to a dynamic scope name
+  resolve :is_public, :scope => -> (value) { value == true ? :is_public : :is_private}
 
-  # Resolve :is_public argument with a different scope name
-  resolve_scope :is_public, -> (value) { value != true }, :scope_name => :is_private
+  # Resolve :is_public to a class method
+  resolve :custom_arg, :custom_resolve_method
 
-  def is_public(value)
-    @result.is_public if value
-    @result.is_private unless value
+  def custom_resolve_method(value)
+    ...
   end
 
+  # Resolve :is_public to a method on the model object
+  resolve :custom_arg, :model_obj_method
+
 end
 ```
 
-In the example above, there are three declarations:
+In the examples above, the three primary arguments to `resolve` are:
+
+`resolve :argument_name, ...`
 
-`resolve_where` is a declarative approach using `ActiveRecord.where` to resolve arguments.
+`where` to specify another attribute.
 
-`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.
+`scope` to specify a scope on the model:
+- `scope` accepts string/symbol "scope name" or a closure that returns a scope name or `nil`
 - 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.
 
-`resolve_method` is an imperative approach that allows completely custom resolution.
+Alternatively you can specify a symbol representing a method name: (ie: `resolve :arg_1, :custom_method`). The resolver will use it's own method if it exists, or else it will call the method on the object itself.
 
 
 
@@ -156,7 +157,7 @@ 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. 
+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](https://github.com/colepatrickturner))

data/lib/graphql/rails/resolver.rb

@@ -1,7 +1,7 @@
 module GraphQL
   module Rails
     class Resolver
-      VERSION = '0.1.3'
+      VERSION = '0.1.4'
 
       attr_accessor :resolvers
 
@@ -15,6 +15,7 @@ module GraphQL
         @args = nil
         @ctx = nil
         @resolvers = self.class.resolvers
+        @id_field = self.class.id_field
       end
 
       def call(obj, args, ctx)
@@ -25,13 +26,62 @@ module GraphQL
         @result = @callable.call(obj, args, ctx)
 
         # If there's an ID type, offer ID resolution_strategy
-        if has_id_field and args.key? :id
-          lookup_id(args[:id])
+        if has_id_argument and args.key? @id_field
+          lookup_id(args[@id_field])
         end
 
-        @resolvers.each do |field,method|
+        @resolvers.each do |field,resolvers|
           if args.key? field
-            @result = method.call(@result, args[field])
+            value = args[field]
+
+            resolvers.each do |method, params|
+              # Match scopes
+              if params.key? :scope
+                scope_name = params[:scope]
+                scope_name = scope_name.call(value) if scope_name.respond_to? :call
+
+                scope_args = []
+                scope_args.push(value) if params.key? :with_value && params[:with_value] == true
+
+                @result = @result.send(scope_name) unless scope_name.nil?
+              # Match custom methods
+              elsif params.key? :method
+                @result = send(params[:method], value)
+              elsif method.present?
+                # Match first param
+                if method.respond_to? :call
+                  # Match implicit blocks
+                  @result = method.call(value)
+                elsif self.respond_to? method
+                  # Match method name to current resolver class
+                  @result = send(method, value)
+                elsif @result.respond_to? method
+                  # Match method name to object
+                  @result = @result.send(method, value)
+                else
+                  raise ArgumentError, "Unable to resolve parameter of type #{method.class} in #{self}"
+                end
+              elsif params.size < 1
+                if self.respond_to? field
+                  @result = send(field, value)
+                elsif @result.method_defined? field and params[:where].present? == false
+                  @result = @result.send(field, value)
+                else
+                  attribute =
+                    if params[:where].present?
+                      params[:where]
+                    else
+                      field
+                    end
+
+                  hash = {}
+                  hash[attribute] = value
+                  @result = @result.where(hash)
+                end
+              else
+                raise ArgumentError, "Unable to resolve field #{field} in #{self}"
+              end
+            end
           end
         end
 
@@ -57,8 +107,22 @@ module GraphQL
         @ctx.ast_node.name
       end
 
+      def has_id_argument
+        @ctx.irep_node.definitions.any? do |type_defn, field_defn|
+          if field_defn.name === field_name
+            field_defn.arguments.any? do |k,v|
+              v.type == ::GraphQL::ID_TYPE or
+              (v.type.kind == ::GraphQL::TypeKinds::LIST and v.type.of_type == ::GraphQL::ID_TYPE)
+            end
+          else
+            false
+          end
+        end
+      end
+
       def has_id_field
-        @ctx.irep_node.children.any? {|x| x[1].return_type == GraphQL::ID_TYPE }
+        warn "[DEPRECATION] `has_id_field` is deprecated.  Please use `has_id_argument` instead."
+        has_id_argument
       end
 
       def connection?
@@ -77,62 +141,63 @@ module GraphQL
         "::#{self.class.name.demodulize}".constantize
       end
 
-      def lookup_id(value)
+      def to_model_id(value)
         if is_global_id(value)
           type_name, id = NodeIdentification.from_global_id(value)
           constantized = "::#{type_name}".constantize
 
           if constantized == model
-            @result = @result.where(:id => id)
+            id
           else
             nil
           end
         else
-          @result = @result.where(:id => value)
+          value
+        end
+      end
+
+      def lookup_id(value)
+        if value.kind_of? Array
+          value = value.map { |v| to_model_id(v) }.compact
         end
+
+        @result = @result.where(:id => value)
       end
 
       class << self
+        @@id_field = :id
+
+        def id_field
+          @@id_field
+        end
 
         def resolvers
           @resolvers ||= {}
           @resolvers
         end
 
-        def resolve(field, method)
+        def resolve(field, definition=nil, **otherArgs)
           @resolvers ||= {}
-          @resolvers[field] = method
+          @resolvers[field] ||= []
+          @resolvers[field].push([definition, otherArgs])
         end
 
         def resolve_where(field)
-          resolve(field, lambda { |obj, value|
-            where = {}
-            where[field] = value
-
-            obj.where(where)
-          })
+          warn "[DEPRECATION] `resolve_where` is deprecated.  Please use `resolve` instead."
+          resolve(field)
         end
 
         def resolve_scope(field, test=nil, scope_name: nil, with_value: false)
+          warn "[DEPRECATION] `resolve_scope` is deprecated.  Please use `resolve` instead."
           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
-          })
+          resolve(field, :scope => -> (value) { test.call(value) ? scope_name : nil }, :with_value => with_value)
         end
 
         def resolve_method(field)
-          resolve(field, lambda { |obj, value|
-            obj.send(field, value)
-          })
+          warn "[DEPRECATION] `resolve_method` is deprecated.  Please use `resolve` instead."
+          resolve(field)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-resolver
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Cole Turner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-28 00:00:00.000000000 Z
+date: 2016-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql