graphql-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 213d171fcd46bcfca65679b3af693a3c77e9e3eb
+  data.tar.gz: ebfd301985d54acc70f1150b85a86c2f2f3be9f8
+SHA512:
+  metadata.gz: 5aa16322431206472f7d22de81f61d516d44b93357aa3b6d45e3c6776dd2983e27b7440015c853466188c1ce01ab04c050124b6a0034903fa27a60d5d07cfb1a
+  data.tar.gz: d9cfc59ecdd63c43d2f9c4a8f74912d340d1decd7fa339f3cfbf2e81ad206890a110bba893cc0a520b7e6908e42bce08f23e90228b84618cddb72b4e0e30a0d1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Colin Walker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,256 @@
+# GraphQL-Api
+GraphQL-Api is an opinionated Graphql framework for Rails that supports 
+auto generating queries based on Active Record models and plain Ruby 
+objects.
+
+## Example
+
+Given the following model structure:
+
+```ruby
+class Author < ActiveRecord::Base
+  has_many :blogs
+  # columns: name
+end
+
+class Blog < ActiveRecord::Base
+  belongs_to :author
+  # columns: title, content
+end
+```
+
+GraphQL-Api will respond to the following queries for the blog resource:
+
+```graphql
+query { blog(id: 1) { id, title, author { name } } }
+
+query { blogs(limit: 5) { id, title, author { name } } }
+
+mutation { createBlog(input: {name: "test", author_id: 2}) { blog { id } } }
+
+mutation { updateBlog(input: {id: 1, title: "test"}) { blog { id } } }
+
+mutation { deleteBlog(input: {id: 1}) { blog_id } }
+```
+
+GraphQL-Api also has support for command objects:
+```ruby
+# Graphql mutation derived from the below command object:
+# mutation { blogCreateCommand(input: {tags: ["test", "testing"], name: "hello"}) { blog { id, tags { name } } } }
+
+class BlogCreateCommand < GraphQL::Api::CommandType
+  inputs name: :string, tags: [:string]
+  returns blog: Blog
+
+  def perform
+    # do something here to add some tags to a blog, you could also use ctx[:current_user] to access the user
+    {blog: blog}
+  end
+
+end
+```
+
+... and query objects:
+```ruby
+# Graphql query derived from the below query object:
+# query { blogQuery(content_matches: ["name"]) { id, name } }
+
+class BlogQuery < GraphQL::Api::QueryType
+  arguments name: :string, content_matches: [:string]
+  return_type [Blog]
+
+  def execute
+    Blog.all
+  end
+
+end
+```
+
+## Contents
+
+1. [Guides](#guides)
+2. [Documentation](#documentation)
+3. [Roadmap](#roadmap)
+
+## Guides
+
+### Endpoint
+
+Creating an endpoint for GraphQL-Api.
+
+```ruby
+# inside an initializer or other file inside the load path
+GraphSchema = GraphQL::Api::Schema.new.schema
+
+# controllers/graphql_controller.rb
+class GraphqlController < ApplicationController
+
+  # needed by the relay framework, defines the graphql schema
+  def index
+    render json: GraphSchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
+  end
+
+  # will respond to graphql requests and pass through the current user
+  def create
+    render json: GraphSchema.execute(
+        params[:query], 
+        variables: params[:variables] || {}, 
+        context: {current_user: current_user}
+    )
+  end
+  
+end
+```
+
+### Authorization
+
+GraphQL-Api will check for an `access_<field>?(ctx)` method on all model 
+objects before returning the  value. If this method returns false, the 
+value will be `nil`.
+
+To scope queries for the model, define the `graph_find(args, ctx)` and 
+`graph_where(args, ctx)` methods using the `ctx` parameter to get the
+current user and apply a scoped query. For example:
+
+```ruby
+class Blog < ActiveRecord::Base
+  belongs_to :author
+  
+  def self.graph_find(args, ctx)
+    ctx[:current_user].blogs.find(args[:id])
+  end
+  
+  def access_content?(ctx)
+    ctx[:current_user].is_admin?
+  end
+  
+end
+```
+
+For more complicated access management, define query objects and Poro's
+with only a subset of fields that can be accessed.
+
+Future work is this area is ongoing. For example, a CanCan integration 
+could be a much simpler way of separating out this logic.
+
+## Documentation
+
+### Querying
+
+Instantiate an instance of GraphQL-Api and get the `schema` object which is
+a `GraphQL::Schema` instance from [graphql-ruby](https://rmosolgo.github.io/graphql-ruby).
+
+```ruby
+graph = GraphQL::Api::Schema.new(commands: [], models: [], queries: [])
+graph.schema.execute('query { ... }')
+```
+
+GraphQL-Api will load in all models, query objects and commands from the rails
+app directory automatically. If you store these in a different location
+you can pass them in directly to the new command.
+
+### Model Objects
+
+Model objects are the core return value from GraphQL-Api. They can be a plain
+old ruby object or they can be an active record model. Active record models
+have more automatic inference, whereas poro objects are more flexible.
+
+#### Active Record
+
+GraphQL-Api reads your associations and columns from your models and creates
+a graphql schema from them. In the examples above you can see that 'Author'
+is automatically accessible from the 'Blog' object because the belongs to
+relationship is set up. Column types are also inferred.
+
+GraphQL-Api will set up two queries on the main Graphql query object. One for
+a single record and another for a collection. You can override these queries
+by setting a `graph_find(args, ctx)` and `graph_where(args, ctx)` class 
+methods on your model. The `ctx` parameter will contain the context passed
+in from the controller while the `args` parameter will contain the arguments
+passed into the graphql query.
+
+#### Poro
+
+Plain old ruby objects are supported by implementing a class method called
+`fields` on the object that returns the expected [types](#types) hash. 
+Methods on the Poro should be defined with the same name as the provided
+fields.
+
+### Command Objects
+
+Command objects are an object oriented approach to defining mutations.
+They take a set of inputs as well as a graphql context and provide a
+`perform` method that returns a Graphql understandable type. These objects
+give you an object oriented abstraction for handling mutations.
+
+Command objects must implement the interface defined in `GraphQL::Api::CommandType`
+
+### Query Objects
+
+Query objects are designed to provide a wrapper around complex queries
+with potentially a lot of inputs. They return a single type or array of
+types.
+
+Query objects must implement the interface defined in `GraphQL::Api::QueryType`
+
+### Customization
+
+Sometimes you cannot fit every possible use case into a library like GraphQL-Api
+as a result, you can always drop down to the excellent Graphql library for
+ruby to combine both hand rolled and GraphQL-Api graphql schemas. Here is an
+example creating a custom mutation.
+
+```ruby
+simple_mutation = GraphQL::Relay::Mutation.define do
+  input_field :name, !types.String
+  return_field :item, types.String
+  resolve -> (inputs, ctx) {  {item: 'hello'}  }
+end
+
+graph = GraphQL::Api::Schema.new
+mutation = graph.mutation do
+  field 'simpleMutation', simple_mutation.field
+end
+
+schema = GraphQL::Schema.define(query: graph.query, mutation: mutation)
+puts schema.execute('mutation { simpleMutation(input: {name: "hello"}) { item } }')
+```
+
+The `GraphQL::Api::Schema#mutation` and `GraphQL::Api::Schema#query` methods accept
+a block that allows you to add custom fields or methods to the mutation or
+query definitions. You can refer to the [graphql-ruby](https://rmosolgo.github.io/graphql-ruby)
+docs for how to do this.
+
+### Types
+
+Field types and argument types are all supplied as a hash of key value 
+pairs. An exclamation mark at the end of the type marks it as required, 
+and wrapping the type in an array marks it as a list of that type.
+
+```ruby
+{
+    name: :string,
+    more_names: [:string],
+    required: :integer!,
+}
+```
+
+The supported types are:
+
+- integer
+- text
+- string
+- decimal
+- float
+- boolean
+
+Note, these are the same as active record's column types for consistency.
+
+
+## Roadmap
+
+- [ ] Customizing resolvers
+- [ ] CanCan support
+- [ ] Relay support
+- [ ] Additional object support (enums, interfaces ...)
+- [ ] Support non rails frameworks

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Graphite'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/graphql/api.rb

@@ -0,0 +1,16 @@
+require "graphql/api/version"
+require "graphql/api/schema"
+
+module GraphQL
+  module Api
+
+    def self.schema(opts={})
+      GraphQL::Api::Schema.new(opts).schema
+    end
+
+    def self.graph(opts={})
+      GraphQL::Api::Schema.new(opts)
+    end
+
+  end
+end

data/lib/graphql/api/command_type.rb

@@ -0,0 +1,24 @@
+module GraphQL::Api
+  class CommandType
+    attr_accessor :ctx, :inputs
+
+    def initialize(inputs, ctx)
+      @inputs = inputs
+      @ctx = ctx
+    end
+
+    def self.inputs(inputs=nil)
+      @inputs = inputs if inputs
+      @inputs || {}
+    end
+
+    def self.returns(fields=nil)
+      @returns = fields if fields
+      @returns || {}
+    end
+
+    def perform
+    end
+
+  end
+end

data/lib/graphql/api/helpers.rb

@@ -0,0 +1,88 @@
+require 'graphql/api/schema_error'
+
+module GraphQL::Api
+  module Helpers
+    def all_constants(root)
+      begin
+        Dir["#{Rails.root}/app/#{root}/*"].map do |f|
+          file = f.split('/')[-1]
+          if file.end_with?('.rb')
+            const = file.split('.')[0].camelize.constantize
+            const unless const.try(:abstract_class)
+          end
+        end.compact
+      rescue
+        []
+      end
+    end
+
+    def graphql_type_for_object(return_type, object_types)
+      if return_type.nil?
+        raise SchemaError.new("return type is nil for object")
+      end
+
+      if return_type.respond_to?(:to_sym) || (return_type.is_a?(Array) && return_type[0].respond_to?(:to_sym))
+        type = graphql_type_of(return_type.to_sym)
+      elsif return_type.is_a?(Array)
+        type = object_types[return_type[0]].to_list_type
+      else
+        type = object_types[return_type]
+      end
+
+      if type.nil?
+        raise SchemaError.new("could not parse return type for: #{return_type}")
+      end
+
+      type
+    end
+
+    def graphql_type_of(type)
+
+      is_required = false
+      if type.to_s.end_with?('!')
+        is_required = true
+        type = type.to_s.chomp('!').to_sym
+      end
+
+      is_list = false
+      if type.is_a?(Array)
+        is_list = true
+        type = type[0]
+      end
+
+      case type
+        when :integer
+          res = GraphQL::INT_TYPE
+        when :text
+          res = GraphQL::STRING_TYPE
+        when :string
+          res = GraphQL::STRING_TYPE
+        when :decimal
+          res = GraphQL::FLOAT_TYPE
+        when :float
+          res = GraphQL::FLOAT_TYPE
+        when :boolean
+          res = GraphQL::BOOLEAN_TYPE
+        else
+          res = GraphQL::STRING_TYPE
+      end
+
+      res = res.to_list_type if is_list
+      res = !res if is_required
+
+      res
+    end
+
+    def graphql_type(column)
+      graphql_type_of(column.type)
+    end
+
+    def graphql_fetch(obj, ctx, name)
+      if obj.respond_to?("access_#{name}?")
+        obj.send(name) if obj.send("access_#{name}?", ctx)
+      else
+        obj.send(name)
+      end
+    end
+  end
+end

data/lib/graphql/api/query_type.rb

@@ -0,0 +1,24 @@
+module GraphQL::Api
+  class QueryType
+    attr_accessor :ctx, :inputs
+
+    def initialize(inputs, ctx)
+      @inputs = inputs
+      @ctx = ctx
+    end
+
+    def self.arguments(arguments=nil)
+      @arguments = arguments if arguments
+      @arguments || []
+    end
+
+    def self.return_type(type=nil)
+      @return_type = type if type
+      @return_type
+    end
+
+    def execute
+    end
+
+  end
+end

data/lib/graphql/api/schema.rb

@@ -0,0 +1,284 @@
+require 'graphql/api/command_type'
+require 'graphql/api/query_type'
+require 'graphql/api/helpers'
+require 'graphql/api/schema_error'
+require 'graphql'
+
+include GraphQL::Api::Helpers
+
+module GraphQL::Api
+  class Schema
+
+    def initialize(commands: [], queries: [], models: [])
+      @types = {}
+      @mutations = {}
+
+      @load_commands = commands
+      @load_queries = queries
+      @load_models = models
+
+      build_model_types
+      build_mutations
+      build_object_types
+    end
+
+    def all_models
+      @all_models ||= all_constants('models') + @load_models
+    end
+
+    def all_queries
+      @all_queries ||= all_constants('queries') + @load_queries
+    end
+
+    def all_commands
+      @all_commands ||= all_constants('commands') + @load_commands
+    end
+
+    def create_type(model_class)
+      object_types = @types
+
+      GraphQL::ObjectType.define do
+        name model_class.name
+        description "Get #{model_class.name}"
+
+        if model_class.respond_to?(:columns)
+          model_class.columns.each do |column|
+            field column.name do
+              type graphql_type(column)
+              resolve -> (obj, args, ctx) { graphql_fetch(obj, ctx, column.name) }
+            end
+          end
+        end
+
+        if model_class.respond_to?(:fields)
+          model_class.fields.each do |field_name, field_type|
+            field field_name, graphql_type_of(field_type)
+          end
+        end
+
+        if model_class.respond_to?(:reflections)
+          model_class.reflections.each do |name, association|
+            field name do
+              if association.collection?
+                type types[object_types[association.class_name.constantize]]
+              else
+                type object_types[association.class_name.constantize]
+              end
+              resolve -> (obj, args, ctx) { graphql_fetch(obj, ctx, name) }
+            end
+          end
+        end
+
+      end
+    end
+
+    def create_command_type(object_type)
+      object_types = @types
+
+      GraphQL::Relay::Mutation.define do
+        name object_type.name
+        description "Command #{object_type.name}"
+
+        object_type.inputs.each do |input, type|
+          input_field input, graphql_type_of(type)
+        end
+
+        object_type.returns.each do |return_name, return_type|
+          return_field return_name, graphql_type_for_object(return_type, object_types)
+        end
+
+        resolve -> (inputs, ctx) {
+          object_type.new(inputs, ctx).perform
+        }
+      end
+    end
+
+    def create_mutation(model_class)
+      return nil unless model_class < ActiveRecord::Base
+
+      object_types = @types
+
+      GraphQL::Relay::Mutation.define do
+        name "Create#{model_class.name}"
+        description "Create #{model_class.name}"
+
+        model_class.columns.each do |column|
+          input_field column.name, graphql_type(column)
+        end
+
+        return_field model_class.name.underscore.to_sym, object_types[model_class]
+
+        resolve -> (inputs, ctx) {
+          item = model_class.create!(inputs.to_h)
+          {model_class.name.underscore.to_sym => item}
+        }
+      end
+    end
+
+    def update_mutation(model_class)
+      return nil unless model_class < ActiveRecord::Base
+
+      object_types = @types
+
+      GraphQL::Relay::Mutation.define do
+        name "Update#{model_class.name}"
+        description "Update #{model_class.name}"
+
+        input_field :id, !types.ID
+        model_class.columns.each do |column|
+          input_field column.name, graphql_type(column)
+        end
+
+        return_field model_class.name.underscore.to_sym, object_types[model_class]
+
+        resolve -> (inputs, ctx) {
+          item = model_class.find(inputs[:id])
+          item.update!(inputs.to_h)
+          {model_class.name.underscore.to_sym => item}
+        }
+      end
+    end
+
+    def delete_mutation(model_class)
+      return nil unless model_class < ActiveRecord::Base
+
+      GraphQL::Relay::Mutation.define do
+        name "Delete#{model_class.name}"
+        description "Delete #{model_class.name}"
+
+        input_field :id, !types.ID
+
+        return_field "#{model_class.name.underscore}_id".to_sym, types.ID
+
+        resolve -> (inputs, ctx) {
+          item = model_class.find(inputs[:id]).destroy!
+          {"#{model_class.name.underscore}_id".to_sym => item.id}
+        }
+      end
+    end
+
+    def query(&block)
+      object_types = @types
+
+      @query ||= GraphQL::ObjectType.define do
+        name 'Query'
+        description 'The query root for this schema'
+
+        instance_eval(&block) if block
+
+        object_types.each do |object_class, graph_type|
+          if object_class < ActiveRecord::Base
+
+            field(object_class.name.camelize(:lower)) do
+              type graph_type
+              argument :id, types.ID
+
+              if object_class.respond_to?(:arguments)
+                object_class.arguments.each do |arg|
+                  argument arg, graphql_type(object_class.columns.find { |c| c.name.to_sym == arg.to_sym })
+                end
+              end
+
+              resolve -> (obj, args, ctx) {
+                if object_class.respond_to?(:graph_find)
+                  object_class.graph_find(args, ctx)
+                else
+                  object_class.find_by!(args.to_h)
+                end
+              }
+            end
+
+            field(object_class.name.camelize(:lower).pluralize) do
+              type types[graph_type]
+              argument :limit, types.Int
+
+              if object_class.respond_to?(:arguments)
+                object_class.arguments.each do |arg|
+                  argument arg, graphql_type(object_class.columns.find { |c| c.name.to_sym == arg.to_sym })
+                end
+              end
+
+              resolve -> (obj, args, ctx) {
+                if object_class.respond_to?(:graph_where)
+                  object_class.graph_where(args, ctx)
+                else
+                  eager_load = []
+                  ctx.irep_node.children.each do |child|
+                    eager_load << child[0] if object_class.reflections.find { |name, _| name == child[0] }
+                  end
+
+                  query_args = args.to_h
+                  query_args.delete('limit')
+
+                  q = object_class.where(query_args)
+                  q.eager_load(*eager_load) if eager_load.any?
+                  q.limit(args[:limit] || 30)
+                end
+              }
+            end
+
+          elsif object_class.respond_to?(:arguments) && object_class.respond_to?(:return_type)
+
+            field(object_class.name.camelize(:lower)) do
+              type(graphql_type_for_object(object_class.return_type, object_types))
+
+              object_class.arguments.each do |argument_name, argument_type|
+                argument argument_name, graphql_type_of(argument_type)
+              end
+
+              resolve -> (obj, args, ctx) {
+                object_class.new(args, ctx).execute
+              }
+            end
+
+          end
+        end
+
+      end
+    end
+
+    def mutation(&block)
+      mutations = @mutations
+
+      @mutation ||= GraphQL::ObjectType.define do
+        name 'Mutation'
+        instance_eval(&block) if block
+
+        mutations.each do |model_class, muts|
+          muts.each do |mutation|
+            field mutation[0], field: mutation[1].field
+          end
+        end
+      end
+    end
+
+    def schema
+      @schema ||= GraphQL::Schema.define(query: query, mutation: mutation)
+    end
+
+    def build_model_types
+      all_models.each { |model_class| @types[model_class] = create_type(model_class) }
+    end
+
+    def build_object_types
+      all_queries.each { |query| @types[query] = nil }
+    end
+
+    def build_mutations
+      all_models.each do |model_class|
+        @mutations[model_class] = [
+            ["create#{model_class.name}", create_mutation(model_class)],
+            ["update#{model_class.name}", update_mutation(model_class)],
+            ["delete#{model_class.name}", delete_mutation(model_class)],
+        ].map { |x| x if x[1] }.compact
+      end
+
+      all_commands.each do |command|
+        @mutations[command] = [
+            [command.name.camelize(:lower), create_command_type(command)]
+        ]
+      end
+    end
+
+  end
+end

data/lib/graphql/api/schema_error.rb

@@ -0,0 +1,4 @@
+module GraphQL::Api
+  class SchemaError < Exception
+  end
+end

data/lib/graphql/api/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Api
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: graphql-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Colin Walker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: 
+email:
+- colinwalker270@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/graphql/api.rb
+- lib/graphql/api/command_type.rb
+- lib/graphql/api/helpers.rb
+- lib/graphql/api/query_type.rb
+- lib/graphql/api/schema.rb
+- lib/graphql/api/schema_error.rb
+- lib/graphql/api/version.rb
+homepage: https://github.com/coldog/graphql-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Rails graphql framework.
+test_files: []