graphql_rails 0.6.0 → 1.2.0

data/README.md

@@ -1,194 +0,0 @@
-# GraphqlRails
-
-[![Build Status](https://travis-ci.org/samesystem/graphql_rails.svg?branch=master)](https://travis-ci.org/samesystem/graphql_rails)
-[![codecov](https://codecov.io/gh/samesystem/graphql_rails/branch/master/graph/badge.svg)](https://codecov.io/gh/samesystem/graphql_rails)
-[![Documentation](https://readthedocs.org/projects/ansicolortags/badge/?version=latest)](https://samesystem.github.io/graphql_rails)
-
-Rails style structure for GraphQL API.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'graphql_rails'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install graphql_rails
-
-## Usage
-
-### Define GraphQL schema as RoR routes
-
-```ruby
-MyGraphqlSchema = GraphqlRails::Router.draw do
-  # will create createUser, updateUser, deleteUser mutations and user, users queries.
-  # expects that UsersController class exist
-  resources :users
-
-  # if you want custom queries or mutation
-  query 'searchLogs', to: 'logs#search' # redirects request to LogsController
-  mutation 'changeUserPassword', to: 'users#change_password'
-end
-```
-
-### Define your Graphql model
-
-```ruby
-class User # works with any class including ActiveRecord
-  include GraphqlRails::Model
-
-  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
-
-    c.attribute :email, type: :string
-    c.attribute :surname, type: :string
-  end
-end
-```
-
-### Define controller
-
-```ruby
-class UsersController < GraphqlRails::Controller
-  # 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
-
-  def change_user_password
-    user = User.find(params[:id])
-    user.update!(password: params[:password])
-
-    # returned value needs to have all methods defined in model `graphql do` part
-    user # or SomeDecorator.new(user)
-  end
-
-  action(:search).permit(search_fields!: SearchFieldsInput) # you can specify your own input fields
-  def search
-  end
-end
-```
-
-## Routes
-
-```ruby
-MyGraphqlSchema = GraphqlRails::Router.draw do
-  # generates `friend`, `createFriend`, `updateFriend`, `destroyFriend`, `friends` routes
-  resources :friends
-  resources :shops, only: [:show, :index] # generates `shop` and `shops` routes only
-  resources :orders, except: :update # generates all routes except `updateOrder`
-
-  resources :users do
-    # generates `findUser` query
-    query :find, on: :member
-
-    # generates `searchUsers` query
-    query :search, on: :collection
-  end
-
-  # you can use namespaced controllers too:
-  scope module: 'admin' do
-    # `updateTranslations` route will be handeled by `Admin::TranslationsController`
-    mutation :updateTranslations, to: 'translations#update'
-
-    # all :groups routes will be handeled by `Admin::GroupsController`
-    resources :groups
-  end
-end
-```
-
-## Testing your GraphqlRails::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
-```
-
-## Detailed documentation
-
-Check https://samesystem.github.io/graphql_rails for more details
-
-## 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.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/samesystem/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
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## 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/samesystem/graphql_rails/blob/master/CODE_OF_CONDUCT.md).

data/lib/graphql_rails/attribute.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphql'
-require 'graphql_rails/attribute/attributable'
-
-module GraphqlRails
-  # contains info about single graphql attribute
-  class Attribute
-    include Attributable
-
-    attr_reader :property, :description
-
-    def initialize(name, type = nil, description: nil, property: name)
-      @initial_type = type
-      @initial_name = name
-      @description = description
-      @property = property.to_s
-    end
-
-    def field_args
-      [field_name, graphql_field_type, { property: property.to_sym, description: description }]
-    end
-
-    protected
-
-    attr_reader :initial_type, :initial_name
-  end
-end

data/lib/graphql_rails/attribute/type_parser.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphql'
-
-module GraphqlRails
-  class Attribute
-    # converts string value in to GraphQL type
-    class TypeParser
-      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 graphql_type
-        return unparsed_type if raw_graphql_type?
-
-        if list?
-          parsed_list_type
-        else
-          parsed_inner_type
-        end
-      end
-
-      def graphql_model
-        type_class = inner_type_name.safe_constantize
-        return unless type_class.respond_to?(:graphql)
-
-        type_class
-      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) ||
-          unparsed_type.is_a?(GraphQL::InputObjectType) ||
-          (defined?(GraphQL::Schema::Member) && unparsed_type.is_a?(Class) && unparsed_type < GraphQL::Schema::Member)
-      end
-
-      def inner_type_name
-        unparsed_type.to_s.tr('[]!', '')
-      end
-
-      def type_by_name
-        TYPE_MAPPING.fetch(inner_type_name.downcase) do
-          dynamicly_defined_type || raise(
-            UnknownTypeError,
-            "Type #{unparsed_type.inspect} is not supported. Supported scalar types are: #{TYPE_MAPPING.keys}." \
-            ' All the classes that includes `GraphqlRails::Model` are also supported as types.'
-          )
-        end
-      end
-
-      def dynamicly_defined_type
-        type_class = graphql_model
-        return unless type_class
-
-        type_class.graphql.graphql_type
-      end
-    end
-  end
-end

data/lib/graphql_rails/controller/controller_function.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphql_rails/controller/action'
-require_relative 'request'
-require_relative 'action'
-
-module GraphqlRails
-  class Controller
-    # graphql resolver which redirects actions to appropriate controller and controller action
-    class ControllerFunction < GraphQL::Function
-      # accepts path of given format "controller_name#action"
-      attr_reader :type
-
-      def initialize(controller:, action_name:, type:)
-        @controller = controller
-        @action_name = action_name
-        @type = type
-      end
-
-      def self.from_route(route)
-        action = Action.new(route)
-
-        action_function_class(action).new(
-          controller: action.controller,
-          action_name: action.name,
-          type: action.return_type
-        )
-      end
-
-      def self.action_function_class(action)
-        Class.new(self) do
-          description(action.description)
-
-          action.arguments.each do |attribute|
-            argument(*attribute.function_argument_args)
-          end
-        end
-      end
-
-      def call(object, inputs, ctx)
-        request = Request.new(object, inputs, ctx)
-        controller.new(request).call(action_name)
-      end
-
-      private
-
-      attr_reader :controller, :action_name
-    end
-  end
-end

data/lib/graphql_rails/controller/format_results.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module GraphqlRails
-  class Controller
-    # Convers raw controller results in to graphql-friendly format
-    class FormatResults
-      def initialize(original_result, action_config:, params:, graphql_context:)
-        @original_result = original_result
-        @action_config = action_config
-        @controller_params = params
-        @graphql_context = graphql_context
-      end
-
-      def call
-        if action_config.paginated? && original_result
-          paginated_result
-        else
-          original_result
-        end
-      end
-
-      private
-
-      attr_reader :original_result, :action_config, :controller_params, :graphql_context
-
-      def paginated_result
-        pagination_params = controller_params.slice(:first, :last, :before, :after)
-        pagination_options = action_config.pagination_options.merge(context: graphql_context)
-
-        GraphQL::Relay::BaseConnection
-          .connection_for_nodes(original_result)
-          .new(original_result, pagination_params, pagination_options)
-      end
-    end
-  end
-end

data/lib/graphql_rails/model/graphql_type_builder.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module GraphqlRails
-  module Model
-    # stores information about model specific config, like attributes and types
-    class GraphqlTypeBuilder
-      def initialize(name:, description: nil, attributes:)
-        @name = name
-        @attributes = attributes
-        @description = description
-      end
-
-      def call
-        type_name = name
-        type_description = description
-        type_attributes = attributes
-
-        GraphQL::ObjectType.define do
-          name(type_name)
-          description(type_description)
-
-          type_attributes.each_value do |attribute|
-            field(*attribute.field_args)
-          end
-        end
-      end
-
-      private
-
-      attr_reader :model_configuration, :attributes, :name, :description
-    end
-  end
-end