graphql-rails-resolver 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eac8d006df6f747647df533f2606819a2b6e304a
+  data.tar.gz: c2d7486872ecc83c143fd1654f369ab8fc58045e
+SHA512:
+  metadata.gz: de1cd692a89ecf230ede5977aecf4e36a6ad5be227354643228d139c620f6e281547a8d259560a80e6016c3a3cbb6db8b3bf0bd691963d3ae71cb997eff14d91
+  data.tar.gz: a5de48a5fb24727abd8f92f39fb3946f9e913aa8ca2116d6ecff9bc107e3110f1568f4d07398d550f5a7fa5e211e9ebb7d4c829ccb2ba4068b2dc0a667753f4f

data/README.md

@@ -0,0 +1,154 @@
+# 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.
+
+# 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.
+
+## Why?
+**tl;dr; Active Resolvers achieves three goals: maintainable query type, code re-use, and a declarative integration with Ruby on Rails.**
+
+Take for example the following Rails model:
+
+```
+class Post < ApplicationRecord
+  belongs_to :author
+  has_many :comments
+
+  scope :is_public, -> { where(is_public: true) }
+  scope :is_private, -> { where(is_public: false) }
+
+  def tags
+     ["hello", "world"]
+  end
+
+end
+```
+
+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]
+    }
+end
+```
+
+This implementation is cumbersome and when your application grows it will become unmanageable. In [GraphQL Ruby: Clean Up your Query Type](https://m.alphasights.com/graphql-ruby-clean-up-your-query-type-d7ab05a47084) we see a better pattern emerge for building resolvers that can be re-used.
+
+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
+end
+```
+
+**/app/graph/resolvers/post.rb**
+```
+module Resolvers
+  class Post
+    def call(_, arguments, _)
+      if arguments[:ids]
+        ::Post.where(id: arguments[:ids])
+      elsif arguments.key? :is_public
+        ::Post.is_public if arguments[:is_public]
+        ::Post.is_private unless arguments[:is_public]
+      else
+        ::Post.all
+      end
+    end
+  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.
+
+
+## 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.
+
+```
+# Class name must match the Rails model name exactly.
+
+class Post < GraphQL::Rails::ActiveResolver
+  # ID argument is resolved within ActiveResolver
+
+  # 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
+
+  def is_public(value)
+    @result.is_public if value
+    @result.is_private unless value
+  end
+
+end
+```
+
+In the example above, there are two 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.
+
+[Help make scopes declarative!](#making-scopes-declarative)
+
+
+
+
+### Detecting the Model
+The resolver will automatically resolve to a Rails model with the same name. This behavior can be overridden by defining a `Post#model` which returns the appropriate model.
+```
+def model
+   ::AnotherModel
+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.
+```
+def lookup_id(value)
+  ...
+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:
+```
+Resolvers::Post.new(Proc.new {
+	::Post.where(:created_at => ...)
+})
+```
+
+
+# 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 }
+```
+
+
+
+# Credits
+- Cole Turner ([@colepatrickturner](/colepatrickturner))
+- Peter Salanki ([@salanki](/salanki))

data/lib/graphql/rails.rb

@@ -0,0 +1,2 @@
+require 'graphql'
+require 'graphql/rails/resolver'

data/lib/graphql/rails/resolver.rb

@@ -0,0 +1,118 @@
+module GraphQL
+  module Rails
+    class Resolver
+      VERSION = '0.1.2'
+
+      def initialize(callable=nil)
+        unless callable.nil?
+          raise ArgumentError, "Resolver requires a callable type or nil" unless callable.respond_to? :call
+        end
+
+        @callable = callable || Proc.new { model.all }
+        @obj = nil
+        @args = nil
+        @ctx = nil
+        @resolvers = {}
+      end
+
+      def call(obj, args, ctx)
+        @obj = obj
+        @args = args
+        @ctx = ctx
+
+        @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])
+        end
+
+        @resolvers.each do |field,method|
+          if args.key? field
+            method
+          end
+        end
+
+        result = payload
+
+        @obj = nil
+        @args = nil
+        @ctx = nil
+
+        result
+      end
+
+      def payload
+        # Return all results if it's a list or a connection
+        if connection? or list?
+          @result.all
+        else
+          @result.first
+        end
+      end
+
+      def field_name
+        @ctx.ast_node.name
+      end
+
+      def has_id_field
+        @ctx.irep_node.children.any? {|x| x[1].return_type == GraphQL::ID_TYPE }
+      end
+
+      def connection?
+        @ctx.irep_node.definitions.all? { |type_defn, field_defn| field_defn.resolve_proc.is_a?(GraphQL::Relay::ConnectionResolve) }
+      end
+
+      def list?
+        @ctx.irep_node.definitions.all? { |type_defn, field_defn| field_defn.type.kind.eql?(GraphQL::TypeKinds::LIST) }
+      end
+
+      def model
+        unless self.class < Resolvers::Base
+          raise ArgumentError, "Cannot call `model` on BaseResolver"
+        end
+
+        "::#{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)
+          constantized = "::#{type_name}".constantize
+
+          if constantized == model
+            @result = @result.where(:id => id)
+          else
+            nil
+          end
+        else
+          @result = @result.where(:id => value)
+        end
+      end
+
+
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: graphql-rails-resolver
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Cole Turner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.14
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A utility for ease graphql-ruby integration into a Rails project.
+email: turner.cole@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/graphql/rails.rb
+- lib/graphql/rails/resolver.rb
+homepage: http://rubygems.org/gems/graphql-rails-resolver
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: GraphQL + Rails integration for Field Resolvers.
+test_files: []