graphql_rails 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 403f0e906eb7580de0e9d7b94c61a260c4145754e157b82906a669e04d4e6297
-  data.tar.gz: 4201cccb9404a1e005ca8b978cd37784ffe400742ec5ae3d338a274a2cb8b84d
+  metadata.gz: 4ddb3b72250678abf86432165a3023bc21f8619635277f35b1322068d4ebab7e
+  data.tar.gz: f13859a7e2ae0bcb65474d33b728354cad3f645d1d2fcab5e34ba1b6f6c7c634
 SHA512:
-  metadata.gz: 1d6f9038ddd9d90597d5b58a3b506b2a3124a547639d9651bdcd4be8f7dbd4feadb487ef7f8ff74062488afdac222eebe2f9a830b6a560921f42400c8fe333ae
-  data.tar.gz: 7135c0208d889a2429b8496337dec43c4fbf6001d6306ea3937cc938eb5b149aa0be74102f49e6a2b613a1ee7751be6769eb9d63df6994aa3b82c523bec4d372
+  metadata.gz: 0be4db6d33d148a0ebf3815f70332c05254a8f4418c71f76381e1f6424d3f4b844a77926ed5f55d53d084b07e0fb7a35d95d7641eb1500b89b9380567b3c188d
+  data.tar.gz: ab4087c4e0af4f4bdbae330ca1c613bcd42ea803f9e70b73a20eae6ea7a400de85c2702b95f339253383fb3df636100dc4898333fbe6560695a2f24bd28a3292

data/.gitignore

@@ -11,3 +11,4 @@
 
 # rspec failure tracking
 .rspec_status
+*.gem

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    graphql_rails (0.1.0)
-      activesupport (~> 5)
+    graphql_rails (0.2.0)
+      activesupport (>= 4)
       graphql (~> 1)
 
 GEM

data/README.md

@@ -1,7 +1,7 @@
 # GraphqlRails
 
-[![Build Status](https://travis-ci.org/povilasjurcys/graphiti.svg?branch=master)](https://travis-ci.org/povilasjurcys/graphiti)
-[![codecov](https://codecov.io/gh/povilasjurcys/graphiti/branch/master/graph/badge.svg)](https://codecov.io/gh/povilasjurcys/graphiti)
+[![Build Status](https://travis-ci.org/povilasjurcys/graphql_rails.svg?branch=master)](https://travis-ci.org/povilasjurcys/graphql_rails)
+[![codecov](https://codecov.io/gh/povilasjurcys/graphql_rails/branch/master/graph/badge.svg)](https://codecov.io/gh/povilasjurcys/graphql_rails)
 
 Rails style structure for GrapQL API.
 
@@ -10,7 +10,7 @@ Rails style structure for GrapQL API.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'graphiti'
+gem 'graphql_rails'
 ```
 
 And then execute:
@@ -19,7 +19,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install graphiti
+    $ gem install graphql_rails
 
 ## Usage
 
@@ -43,7 +43,7 @@ end
 class User # works with any class including ActiveRecord
   include GraphqlRails::Model
 
-  graphiti do |c|
+  graphql do |c|
     # most common attributes, like :id, :name, :title has default type, so you don't have to specify it (but you can!)
     c.attribute :id
 
@@ -65,7 +65,7 @@ class UsersController < GraphqlRails::Controller
     user = User.find(params[:id])
     user.update!(password: params[:password])
 
-    # returned value needs to have all methods defined in model `graphiti do` part
+    # returned value needs to have all methods defined in model `graphql do` part
     user # or SomeDecorator.new(user)
   end
 
@@ -103,6 +103,74 @@ MyGraphqlSchema = GraphqlRails::Router.draw do
 end
 ```
 
+## Testing your GrapqhlRails::Controller in RSpec
+
+### Setup
+
+Add those lines in your `spec/spec_helper.rb` file
+
+```ruby
+# spec/spec_helper.rb
+require 'graphql_rails/rspec_controller_helpers'
+
+RSpec.configure do |config|
+  config.include(GraphqlRails::RSpecControllerHelpers, type: :graphql_controller)
+  # ... your other configuration ...
+end
+```
+
+### Helper methods
+
+There are 3 helper methods:
+
+* `mutation(:your_controller_action_name, params: {}, context: {})`. `params` and `context` are optional
+* `query(:your_controller_action_name, params: {}, context: {})`. `params` and `context` are optional
+* `response`. Response is set only after you call `mutation` or `query`
+
+### Test examples
+
+```ruby
+class MyGraphqlController
+  def index
+    "Called from index: #{params[:message]}"
+  end
+
+  action(:create_user).permit(:full_name, :email)
+  def create_user
+    User.create!(params)
+  end
+end
+
+RSpec.describe MyGraphqlController, type: :graphql_controller do
+  describe '#index' do
+    it 'is successful' do
+      query(:index)
+      expect(response).to be_successful
+    end
+
+    it 'returns correct message' do
+      query(:index, params: { message: 'Hello world!' })
+      expect(response.result).to eq "Called from index: Hello world!"
+    end
+  end
+
+  describe '#create_user' do
+    context 'when bad email is given' do
+      it 'fails' do
+        mutation(:create_user, params { email: 'bad' })
+        expect(response).to be_failure
+      end
+
+      it 'contains errors' do
+        mutation(:create_user, params { email: 'bad' })
+        expect(response.errors).not_to be_empty
+      end
+    end
+  end
+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.
@@ -111,7 +179,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/graphiti. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/graphql_rails. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -119,4 +187,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the GraphqlRails project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/graphiti/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the GraphqlRails project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/graphql_rails/blob/master/CODE_OF_CONDUCT.md).

data/graphql_rails.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'graphql', '~> 1'
-  spec.add_dependency 'activesupport', '~> 5'
+  spec.add_dependency 'activesupport', '>= 4'
 
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/graphql_rails/attribute.rb

@@ -1,25 +1,19 @@
 # frozen_string_literal: true
 
 require 'graphql'
+require 'graphql_rails/attribute/attribute_type_parser'
 
 module GraphqlRails
   # contains info about single graphql attribute
   class Attribute
-    attr_reader :name, :type
+    attr_reader :name, :graphql_field_type, :property, :type_name
 
-    def initialize(name, type = nil, required: false, hidden: false)
+    def initialize(name, type = nil, hidden: false, property: name)
       @name = name.to_s
-      @type = parse_type(type || type_by_attribute_name)
-      @required = required
+      @type_name = type.to_s
+      @graphql_field_type = parse_type(type || type_by_attribute_name)
       @hidden = hidden
-    end
-
-    def graphql_field_type
-      @graphql_field_type ||= required? ? type.to_non_null_type : type
-    end
-
-    def required?
-      @required
+      @property = property.to_s
     end
 
     def hidden?
@@ -51,36 +45,7 @@ module GraphqlRails
     end
 
     def parse_type(type)
-      if graphql_type?(type)
-        type
-      elsif type.is_a?(String) || type.is_a?(Symbol)
-        map_type_name_to_type(type.to_s.downcase)
-      else
-        raise "Unsupported type #{type.inspect} (class: #{type.class})"
-      end
-    end
-
-    def graphql_type?(type)
-      type.is_a?(GraphQL::BaseType) ||
-        type.is_a?(GraphQL::ObjectType) ||
-        (defined?(GraphQL::Schema::Member) && type.is_a?(Class) && type < GraphQL::Schema::Member)
-    end
-
-    def map_type_name_to_type(type_name)
-      case type_name
-      when 'id'
-        GraphQL::ID_TYPE
-      when 'int', 'integer'
-        GraphQL::INT_TYPE
-      when 'string', 'str', 'text', 'time', 'date'
-        GraphQL::STRING_TYPE
-      when 'bool', 'boolean', 'mongoid::boolean'
-        GraphQL::BOOLEAN_TYPE
-      when 'float', 'double', 'decimal'
-        GraphQL::FLOAT_TYPE
-      else
-        raise "Don't know how to parse type with name #{type_name.inspect}"
-      end
+      AttributeTypeParser.new(type).call
     end
   end
 end

data/lib/graphql_rails/attribute/attribute_type_parser.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module GraphqlRails
+  class Attribute
+    # converts string value in to GraphQL type
+    class AttributeTypeParser
+      class UnknownTypeError < ArgumentError; end
+
+      TYPE_MAPPING = {
+        'id' => GraphQL::ID_TYPE,
+
+        'int' => GraphQL::INT_TYPE,
+        'integer' => GraphQL::INT_TYPE,
+
+        'string' => GraphQL::STRING_TYPE,
+        'str' => GraphQL::STRING_TYPE,
+        'text' => GraphQL::STRING_TYPE,
+        'time' => GraphQL::STRING_TYPE,
+        'date' =>  GraphQL::STRING_TYPE,
+
+        'bool' => GraphQL::BOOLEAN_TYPE,
+        'boolean' => GraphQL::BOOLEAN_TYPE,
+
+        'float' => GraphQL::FLOAT_TYPE,
+        'double' => GraphQL::FLOAT_TYPE,
+        'decimal' => GraphQL::FLOAT_TYPE
+      }.freeze
+
+      def initialize(unparsed_type)
+        @unparsed_type = unparsed_type
+      end
+
+      def call
+        return unparsed_type if raw_graphql_type?
+
+        if list?
+          parsed_list_type
+        else
+          parsed_inner_type
+        end
+      end
+
+      private
+
+      attr_reader :unparsed_type
+
+      def parsed_list_type
+        list_type = parsed_inner_type.to_list_type
+
+        if required_list_type?
+          list_type.to_non_null_type
+        else
+          list_type
+        end
+      end
+
+      def parsed_inner_type
+        if required_inner_type?
+          type_by_name.to_non_null_type
+        else
+          type_by_name
+        end
+      end
+
+      def required_inner_type?
+        !!unparsed_type[/\w!/] # rubocop:disable Style/DoubleNegation
+      end
+
+      def list?
+        unparsed_type.to_s.include?(']')
+      end
+
+      def required_list_type?
+        unparsed_type.to_s.include?(']!')
+      end
+
+      def raw_graphql_type?
+        unparsed_type.is_a?(GraphQL::BaseType) ||
+          unparsed_type.is_a?(GraphQL::ObjectType) ||
+          (defined?(GraphQL::Schema::Member) && unparsed_type.is_a?(Class) && unparsed_type < GraphQL::Schema::Member)
+      end
+
+      def inner_type_name
+        unparsed_type.to_s.downcase.tr('[]!', '')
+      end
+
+      def type_by_name
+        TYPE_MAPPING.fetch(inner_type_name) do
+          raise(
+            UnknownTypeError,
+            "Type #{unparsed_type.inspect} is not supported. Supported types are: #{TYPE_MAPPING.keys}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/controller.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'active_support/hash_with_indifferent_access'
-require_relative 'controller/configuration'
-require_relative 'controller/request'
+require 'graphql_rails/controller/configuration'
+require 'graphql_rails/controller/request'
 
 module GraphqlRails
   # base class for all graphql_rails controllers
@@ -26,9 +26,8 @@ module GraphqlRails
     end
 
     def call(method_name)
-      self.class.controller_configuration.before_actions.each { |action_name| send(action_name) }
-
       begin
+        self.class.controller_configuration.before_actions.each { |action_name| send(action_name) }
         response = public_send(method_name)
         render response if graphql_request.no_object_to_return?
       rescue StandardError => error
@@ -42,7 +41,10 @@ module GraphqlRails
 
     attr_reader :graphql_request
 
-    def render(object = nil, error: nil, errors: Array(error))
+    def render(object_or_errors)
+      errors = grapqhl_errors_from_render_params(object_or_errors)
+      object = errors.empty? ? object_or_errors : nil
+
       graphql_request.errors = errors
       graphql_request.object_to_return = object
     end
@@ -50,5 +52,15 @@ module GraphqlRails
     def params
       @params = HashWithIndifferentAccess.new(graphql_request.params)
     end
+
+    private
+
+    def grapqhl_errors_from_render_params(rendering_params)
+      return [] unless rendering_params.is_a?(Hash)
+      return [] if rendering_params.keys.count != 1
+
+      errors = rendering_params[:error] || rendering_params[:errors]
+      Array(errors)
+    end
   end
 end

data/lib/graphql_rails/controller/action.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require_relative 'request'
+
+module GraphqlRails
+  class Controller
+    # analyzes route and extracts controller action related data
+    class Action
+      def initialize(route)
+        @route = route
+      end
+
+      def return_type
+        action_config.return_type || default_type
+      end
+
+      def arguments
+        action_config.attributes.values
+      end
+
+      def controller
+        @controller ||= "#{namespaced_controller_name}_controller".classify.constantize
+      end
+
+      def name
+        @name ||= action_path.split('#').last
+      end
+
+      private
+
+      attr_reader :route
+
+      def default_inner_return_type
+        if action_config.can_return_nil?
+          model_graphql_type
+        else
+          model_graphql_type.to_non_null_type
+        end
+      end
+
+      def default_type
+        type = default_inner_return_type
+        type = type.to_list_type.to_non_null_type if route.collection?
+        type
+      end
+
+      def action_path
+        route.path
+      end
+
+      def module_name
+        route.module_name
+      end
+
+      def action_config
+        controller.controller_configuration.action(name)
+      end
+
+      def namespaced_controller_name
+        [module_name, controller_name].reject(&:empty?).join('/')
+      end
+
+      def controller_name
+        @controller_name ||= action_path.split('#').first
+      end
+
+      def action_model
+        namespace = namespaced_controller_name.singularize.classify.split('::')
+        model_name = namespace.pop
+        model = nil
+
+        while model.nil? && !namespace.empty?
+          model = namespaced_model(namespace, model_name)
+          namespace.pop
+        end
+
+        model || model_name.constantize
+      end
+
+      def namespaced_model(namespace, model_name)
+        [namespace, model_name].join('::').constantize
+      rescue NameError => err
+        raise unless err.message.match?(/uninitialized constant/)
+        nil
+      end
+
+      def model_graphql_type
+        action_model.graphql.graphql_type
+      end
+    end
+  end
+end