graphql_rails 0.8.0 → 1.0.0

data/docs/components/routes.md

@@ -99,3 +99,31 @@ MyGraphqlSchema = GraphqlRails::Router.draw do
   mutation :logIn, to: 'sessions#login' # this will trigger ::SessionsController
 end
 ```
+
+## _group_
+
+You can have multiple routers / schemas. In order to add resources or query only to specific schema, you need wrap it with `group` method, like this:
+
+```ruby
+GraphqlRouter = GraphqlRails::Router.draw do
+  resources :users # goes to all routers
+
+  group :mobile, :internal do
+    resources :admin_users # goes to `mobile` and `internal` schemas
+  end
+
+  query :runTesting, to: 'testing#run', group: :testing # goes to `testing` schema
+end
+```
+
+In order to call specific schema you can call it using `QueryRunner` in your RoR controller:
+
+```ruby
+class InternalController < ApplicationController
+  def execute
+    GraphqlRails::QueryRunner.new(group: :internal, params: params)
+  end
+end
+```
+
+If you want to access raw graphql schema, you can call `GraphqlRouter.graphql_schema(:mobile)`

data/docs/getting_started/quick_start.md

@@ -1,9 +1,16 @@
 # Quick Start
 
+## Generate initial code
+
+```bash
+bundle exec rails g graphql_rails:install
+```
+
 ## Define GraphQL schema as RoR routes
 
 ```ruby
-MyGraphqlSchema = GraphqlRails::Router.draw do
+# config/graphql/routes.rb
+GraphqlRails::Router.draw do
   # will create createUser, updateUser, deleteUser mutations and user, users queries.
   # expects that UsersController class exist
   resources :users
@@ -33,7 +40,7 @@ end
 ## Define controller
 
 ```ruby
-class UsersController < GraphqlRails::Controller
+class UsersController < ApplicationGraphqlController
   # graphql requires to describe which attributes controller action accepts and which returns
   action(:change_user_password)
     .permit(:password!, :id!) # Bang (!) indicates that attribute is required

data/docs/other_tools/query_runner.md

@@ -0,0 +1,49 @@
+# Query Runner
+
+`GraphqlRails::QueryRunner` is a helper class which let's you graphql queries in RoR controller without worrying about parsing details. Here is an example how to use it:
+
+```ruby
+class MyRailsClass < ApplicationController
+  def execute
+    graphql_result = GraphqlRails::QueryRunner.call(
+      params: params, router: GraphqlRouter
+    )
+
+    render json: graphql_result
+  end
+end
+```
+
+## Executing grouped schema
+
+If you have multiple schemas (read [routes section]((components/routes) on how to do that) and you want to render group specific schema, you need to provide group name, like this:
+
+```ruby
+class MyRailsClass < ApplicationController
+  def execute
+    graphql_result = GraphqlRails::QueryRunner.call(
+      group: :internal, # <- custom group name. Can by anything
+      params: params, router: GraphqlRouter
+    )
+
+    render json: graphql_result
+  end
+end
+```
+
+## Providing graphql-ruby options
+
+All graphql-ruby options are also supported, like [execution options](https://graphql-ruby.org/queries/executing_queries.html) or [visibility options](https://graphql-ruby.org/schema/limiting_visibility.html):
+
+```ruby
+class MyRailsClass < ApplicationController
+  def execute
+    graphql_result = GraphqlRails::QueryRunner.call(
+      validate: true, # <- graphql-ruby option
+      params: params, router: GraphqlRouter
+    )
+
+    render json: graphql_result
+  end
+end
+```

data/docs/other_tools/schema_dump.md

@@ -0,0 +1,29 @@
+# Schema Dump
+
+GraphqlRails includes rake task to allow creating schema snapshots easier:
+
+```bash
+rake graphql_rails:schema:dump
+```
+
+## Dumping non default schema
+
+You can have multiple graphql schemas. Read more about this in [routes section]((components/routes). In order to generate schema for one of groups, provide optional `name` argument:
+
+```bash
+rake graphql_rails:schema:dump['your_group_name']
+```
+
+or using env variable `SCHEMA_GROUP_NAME`:
+
+```bash
+SCHEMA_GROUP_NAME=your_group_name rake graphql_rails:schema:dump
+```
+
+## Dumping schema in to non default path
+
+By default schema will be dumped to `spec/fixtures/graphql_schema.graphql` path. If you want different schema path, add `GRAPHQL_SCHEMA_DUMP_PATH` env variable, like this:
+
+```bash
+GRAPHQL_SCHEMA_DUMP_PATH='path/to/my/schema.graphql' rake graphql_rails:schema:dump
+```

data/docs/testing/testing.md

@@ -28,11 +28,13 @@ There are 3 helper methods:
 
 ```ruby
 class MyGraphqlController
+  action(:create_user).permit(:full_name, :email).returns(User)
+  action(:index).returns('String')
+
   def index
     "Called from index: #{params[:message]}"
   end
 
-  action(:create_user).permit(:full_name, :email)
   def create_user
     User.create!(params)
   end

data/graphql_rails.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'graphql', '~> 1'
+  spec.add_dependency 'graphql', '>= 1.9.12'
   spec.add_dependency 'activesupport', '>= 4'
 
   spec.add_development_dependency 'bundler', '~> 1.16'

data/lib/generators/graphql_rails/install_generator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # no-doc
+  module Generators
+    require 'rails/generators/base'
+
+    # Add GraphQL to a Rails app with `rails g graphql_rails:install`.
+    #
+    # Setup a folder structure for GraphQL:
+    #
+    # ```
+    # - app/
+    #   - controllers
+    #     - graphql_controller.rb
+    #     - graphql
+    #       - graphql_application_controller.rb
+    #   - graphql
+    #     - graphql_router.rb
+    # ```
+    class InstallGenerator < Rails::Generators::Base
+      desc 'Install GraphqlRails folder structure and boilerplate code'
+
+      source_root File.expand_path('../templates', __FILE__) # rubocop:disable Style/ExpandPathArguments
+
+      def create_folder_structure
+        empty_directory('app/controllers')
+        template('graphql_controller.erb', 'app/controllers/graphql_controller.rb')
+
+        empty_directory('app/controllers/graphql')
+        template('graphql_application_controller.erb', 'app/controllers/graphql/graphql_application_controller.rb')
+        template('example_users_controller.erb', 'app/controllers/graphql/example_users_controller.rb')
+
+        application do
+          "config.autoload_paths << 'app/graphql'"
+        end
+
+        empty_directory('app/graphql')
+        template('graphql_router.erb', 'app/graphql/graphql_router.rb')
+
+        route('post "/graphql", to: "graphql#execute"')
+
+        if File.directory?('spec') # rubocop:disable Style/GuardClause
+          empty_directory('spec/graphql')
+          template('graphql_router_spec.erb', 'spec/app/graphql/graphql_router_spec.rb')
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql_rails/templates/example_users_controller.erb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Graphql
+  # base class of all GraphqlControllers
+  class ExampleUsersController < GraphqlApplicationController
+    model('String')
+
+    action(:show).permit(id: :ID!).returns_single
+    action(:update).permit(id: :ID!).returns_single
+
+    def show
+      'this is example show action. Remove it and write something real'
+    end
+
+    def update
+      'this is example update action. Remove it and write something real'
+    end
+  end
+end

data/lib/generators/graphql_rails/templates/graphql_application_controller.erb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Graphql
+  # base class of all GraphqlControllers
+  class GraphqlApplicationController < GraphqlRails::Controller
+    # TODO: add app specific customizations here
+  end
+end

data/lib/generators/graphql_rails/templates/graphql_controller.erb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class GraphqlController < ApplicationController
+  skip_before_action :verify_authenticity_token, only: :execute
+
+  def execute
+    render json: GraphqlRails::QueryRunner.call(
+      params: params,
+      context: graphql_context
+    )
+  end
+
+  private
+
+  # data defined here will be accessible via `grapqhl_request.context`
+  # in GraphqlRails::Controller instances
+  def graphql_context
+    {}
+  end
+end

data/lib/generators/graphql_rails/templates/graphql_router.erb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+GraphqlRouter = GraphqlRails::Router.draw do
+  scope module: :graphql do
+    # this will create all CRUD actions for Graphql::UsersController:
+    #   resources :users
+    #
+    # If you want non-CRUD custom actions, you can define them like this:
+    #   query :find_something, to: 'controller_name#action_name'
+    #   mutation :change_something, to: 'controller_name#action_name'
+    # or you can include them in resources part:
+    #   resources :users do
+    #     query :find_one, on: :member
+    #     query :find_many, on: :collection
+    #   end
+
+    resources :example_users, only: %i[show update]
+  end
+end

data/lib/generators/graphql_rails/templates/graphql_router_spec.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe GraphqlRouter do
+  describe '#execute' do
+    it 'returns correct structure' do
+      # if you need to update saved_schema, run rake task:
+      #   $ RAILS_ENV=test rake graphql_rails:schema:dump
+
+      schema_path = Rails.root.join('spec', 'fixtures', 'graphql_schema.graphql')
+      saved_schema = File.read(schema_path).strip
+      real_schema = described_class.to_definition.strip
+
+      expect(real_schema).to eq(saved_schema)
+    end
+  end
+end

data/lib/graphql_rails.rb

@@ -8,6 +8,8 @@ require 'graphql_rails/router'
 require 'graphql_rails/controller'
 require 'graphql_rails/attributes'
 require 'graphql_rails/decorator'
+require 'graphql_rails/query_runner'
+require 'graphql_rails/railtie' if defined?(Rails)
 
 # wonders starts here
 module GraphqlRails

data/lib/graphql_rails/attributes/attributable.rb

@@ -28,17 +28,22 @@ module GraphqlRails
         end
       end
 
+      def required
+        @required = true
+        self
+      end
+
+      def optional
+        @required = false
+        self
+      end
+
       def graphql_model
         type_parser.graphql_model
       end
 
-      def graphql_field_type
-        @graphql_field_type ||= \
-          if required?
-            nullable_type.to_non_null_type
-          else
-            nullable_type
-          end
+      def optional?
+        !required?
       end
 
       protected
@@ -47,15 +52,13 @@ module GraphqlRails
         {}
       end
 
-      def nullable_type
-        type = type_parser.graphql_type
-        type.non_null? ? type.of_type : type
-      end
-
       private
 
       def type_parser
-        @type_parser ||= TypeParser.new(initial_type || attribute_name_parser.graphql_type)
+        @type_parser ||= begin
+          type_for_parser = initial_type || attribute_name_parser.graphql_type
+          TypeParser.new(type_for_parser, paginated: paginated?)
+        end
       end
 
       def attribute_name_parser

data/lib/graphql_rails/attributes/attribute.rb

@@ -2,12 +2,16 @@
 
 require 'graphql'
 require 'graphql_rails/attributes/attributable'
+require 'graphql_rails/input_configurable'
 
 module GraphqlRails
   module Attributes
     # contains info about single graphql attribute
     class Attribute
       include Attributable
+      include InputConfigurable
+
+      attr_reader :attributes
 
       def initialize(name, type = nil, description: nil, property: name, required: nil)
         @initial_type = type
@@ -15,6 +19,7 @@ module GraphqlRails
         @description = description
         @property = property.to_s
         @required = required
+        @attributes ||= {}
       end
 
       def type(new_type = nil)
@@ -41,10 +46,22 @@ module GraphqlRails
       def field_args
         [
           field_name,
-          graphql_field_type,
+          type_parser.type_arg,
+          *description,
+          {
+            method: property.to_sym,
+            null: optional?
+          }
+        ]
+      end
+
+      def argument_args
+        [
+          field_name,
+          type_parser.type_arg,
           {
-            property: property.to_sym,
-            description: description
+            description: description,
+            required: required?
           }
         ]
       end

data/lib/graphql_rails/attributes/input_attribute.rb

@@ -5,12 +5,13 @@ module GraphqlRails
     # contains info about single graphql input attribute
     class InputAttribute
       require_relative './input_type_parser'
+      require_relative './attribute_name_parser'
       include Attributable
 
       attr_reader :description
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(name, type = nil, description: nil, subtype: nil, required: nil, options: {})
+      def initialize(name, type: nil, description: nil, subtype: nil, required: nil, options: {})
         @initial_name = name
         @initial_type = type
         @description = description
@@ -20,26 +21,35 @@ module GraphqlRails
       end
       # rubocop:enable Metrics/ParameterLists
 
-      def function_argument_args
-        [field_name, graphql_input_type, { description: description }]
-      end
-
       def input_argument_args
-        type = raw_input_type || input_type_parser.nullable_type || nullable_type
+        type = raw_input_type || input_type_parser.input_type_arg
 
-        [field_name, type, { required: required?, description: description }]
+        [field_name, type, { required: required?, description: description, camelize: false }]
       end
 
-      def graphql_input_type
-        raw_input_type || input_type_parser.graphql_type || graphql_field_type
+      def paginated?
+        false
       end
 
       private
 
       attr_reader :initial_name, :initial_type, :options, :subtype
 
+      def attribute_name_parser
+        @attribute_name_parser ||= AttributeNameParser.new(
+          initial_name, options: attribute_naming_options
+        )
+      end
+
+      def attribute_naming_options
+        options.slice(:input_format)
+      end
+
       def input_type_parser
-        @input_type_parser ||= InputTypeParser.new(initial_type, subtype: subtype)
+        @input_type_parser ||= begin
+          initial_parseable_type = initial_type || attribute_name_parser.graphql_type
+          InputTypeParser.new(initial_parseable_type, subtype: subtype)
+        end
       end
 
       def raw_input_type