graphql-rails-api 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6402207e57c8de721a10386de5110da04b1bfdacc4b5c81c86acae75ef45e65
-  data.tar.gz: f06272fc40c35d3c7f27df5fcec19e6ed967296fa739559df0d90ab8b21e6847
+  metadata.gz: 066b640b12080a61dc163b4989543cb22cff0c0bc000d5c5f2881ef74a37656a
+  data.tar.gz: '08e978790a84b509ad77c8a0fb58c6d496d891c095092676289c1516fcb478d9'
 SHA512:
-  metadata.gz: 403a79ef9705821684ed7d00283542db925d41ad6cfd40741c5d954d0cb9e0b682286745d01fc70ebf893ba002502133c56b58a21aa72e773e1b4119c96b3163
-  data.tar.gz: e388d99bd961ca380843d8d65b33beba46249373c70ef44d3793797bd5e7a63799b51eb59a62a730b535a879babd1f54033a3ea6bc33d2e75ab12c1d1844ce47
+  metadata.gz: 68ab8d0cc279ca2edebdc20bf3b490b73e8badf3a9f7f0284ef9c3f85c4a1c56ff8f29f8d69d1f16eb7b97e2035e3223308d2f3b093ab5692c40ad560a42cc35
+  data.tar.gz: 44ffdd02ea1cf52065c29db18df694c518ca7b08a9a3264ff25895d702308127265dbce8319ea6e7ce5844df2aeb50f6f3d9c5cdcc4ac0e574675064ab71e58a

data/lib/generators/graphql_connections/graphql_all_connections_generator.rb

@@ -7,14 +7,13 @@ class GraphqlAllConnectionsGenerator < Rails::Generators::NamedBase
     end
   end
 
-  private
-
   def generate_connection(dir, resource)
     File.write(
       "#{dir}/connection.rb",
       <<~STRING
         #{resource.pluralize.camelize}::Connection = #{resource.pluralize.camelize}::Type.define_connection do
           name '#{resource.camelize}Connection'
+
           field :total_count, types.Int do
             resolve ->(obj, _, _) { obj.nodes.count }
           end

data/lib/generators/graphql_mutations/graphql_bulk_update_mutations_generator.rb

@@ -27,17 +27,4 @@ class GraphqlBulkUpdateMutationsGenerator < Rails::Generators::NamedBase
     resource.pluralize.camelize
   end
 
-  def write_at(file_name, line, data)
-    open(file_name, 'r+') do |f|
-      while (line -= 1).positive?
-        f.readline
-      end
-      pos = f.pos
-      rest = f.read
-      f.seek pos
-      f.write data
-      f.write rest
-    end
-  end
-
 end

data/lib/generators/graphql_mutations/graphql_mutations_generator.rb

@@ -8,10 +8,44 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
     generate_create_mutation(dir, resource)
     generate_update_mutation(dir, resource)
     generate_destroy_mutation(dir, resource)
+    generate_bulk_create_mutation(dir, resource)
+    generate_bulk_update_mutation(dir, resource)
   end
 
   private
 
+  def generate_bulk_create_mutation(dir, resource)
+    File.write(
+      "#{dir}/bulk_create.rb",
+      <<~STRING
+        #{resource_class(resource)}::Mutations::BulkCreate = GraphQL::Field.define do
+          description 'creates some #{resource_class(resource).pluralize}'
+          type types[#{resource_class(resource)}::Type]
+
+          argument :#{resource}, types[#{resource_class(resource)}::Mutations::InputType]
+
+          resolve ApplicationService.call(:#{resource}, :bulk_create)
+        end
+      STRING
+    )
+  end
+
+  def generate_bulk_update_mutation(dir, resource)
+    File.write(
+      "#{dir}/bulk_update.rb",
+      <<~STRING
+        #{resource_class(resource)}::Mutations::BulkUpdate = GraphQL::Field.define do
+          description 'Updates some #{resource_class(resource).pluralize}'
+          type types[#{resource_class(resource)}::Type]
+
+          argument :#{resource}, types[#{resource_class(resource)}::Mutations::InputType]
+
+          resolve ApplicationService.call(:#{resource}, :bulk_update)
+        end
+      STRING
+    )
+  end
+
   def generate_create_mutation(dir, resource)
     File.write(
       "#{dir}/create.rb",

data/lib/generators/graphql_rails_api/install_generator.rb

@@ -21,7 +21,7 @@ module GraphqlRailsApi
       write_controller
       if options.action_cable_subs?
         write_websocket_connection
-        write_channel
+        write_online_users_channel
       end
       write_initializer
       write_require_application_rb
@@ -51,6 +51,7 @@ module GraphqlRailsApi
         'app/models/application_record.rb',
         lines_count,
         <<-STRING
+
   def self.visible_for(*)
     all
   end
@@ -59,6 +60,45 @@ module GraphqlRailsApi
     all
   end
 
+        STRING
+      )
+      return unless options.action_cable_subs?
+
+      lines_count = File.read('app/models/application_record.rb').lines.count
+      write_at(
+        'app/models/application_record.rb',
+        lines_count,
+        <<-STRING
+  after_commit :notify_online_users
+
+  def notify_online_users
+    Redis.current.keys('#{Rails.application.class.parent_name.underscore}_subscribed_query_*').each_with_object({}) do |key, hash|
+      hash[
+        key.gsub('#{Rails.application.class.parent_name.underscore}_subscribed_query_', '')
+      ] = Redis.current.hgetall(key).each_with_object([]) do |(data, vars), array|
+        data = data.split('/////')
+        array << { query: data[0], store: data[1], variables: vars.blank? ? nil : JSON.parse(vars), scope: data[2] }
+      end
+    end.each do |user_id, user_queries_array|
+      user_queries_array.map { |user_hash| notify_user(user_id, user_hash) }
+    end
+  end
+
+  def notify_user(user_id, user_hash)
+    model_name = self.class.to_s.underscore
+    if !user_hash[:query].include?(model_name.singularize + '(id: $id') &&
+        !user_hash[:query].include?(' ' + model_name.pluralize)
+      return
+    end
+    return if user_hash[:query].include?(model_name + '(id: $id') && user_hash[:variables]['id'] != id
+
+    u = User.find_by(id: user_id)
+    return unless u
+
+    result = #{Rails.application.class.parent_name}ApiSchema.execute(user_hash[:query], context: { current_user: u }, variables: user_hash[:variables])
+    OnlineUsersChannel.broadcast_to(u, store: user_hash[:store], scope: user_hash[:scope], result: result['data'])
+  end
+
         STRING
       )
     end
@@ -98,9 +138,6 @@ module GraphqlRailsApi
           config = Graphql::Rails::Api::Config.instance
 
           config.id_type = #{options.pg_uuid? ? ':uuid' : ':id'} # :id or :uuid
-
-          # Possibilites are :create, :update or :destroy
-          config.basic_mutations = %i[create update destroy]
         STRING
       )
     end
@@ -125,58 +162,45 @@ module GraphqlRailsApi
       )
     end
 
-    def write_channel
+    def write_online_users_channel
       File.write(
-        'app/channels/graphql_channel.rb',
+        'app/channels/online_users_channel.rb',
         <<~STRING
-          class GraphqlChannel < ApplicationCable::Channel
+          class OnlineUsersChannel < ApplicationCable::Channel
 
             def subscribed
-              @subscription_ids = []
-            end
-
-            # see graphql-ruby from details
-            def execute(data)
-              query, context, variables, operation_name = options_for_execute(data)
-              result = #{@app_name.camelize}Schema.execute(query: query, context: context,
-                                              variables: variables, operation_name: operation_name)
-              payload = { result: result.subscription? ? nil : result.to_h, more: result.subscription?,
-                          errors: result ? result.to_h[:errors] : nil }
-              @subscription_ids << result.context[:subscription_id] if result.context[:subscription_id]
-              transmit(payload)
+              stream_for(current_user)
+              Redis.current.hset('#{Rails.application.class.parent_name.underscore}_online_users', current_user.id, '1')
+              User.online.each do |user|
+                OnlineUsersChannel.broadcast_to(user, User.online_user_ids)
+              end
             end
 
-            def unsubscribed
-              @subscription_ids.each do |sid|
-                #{@app_name.camelize}Schema.subscriptions.delete_subscription(sid)
-              end
+            def subscribe_to_query(data)
+              Redis.current.hset(
+                '#{Rails.application.class.parent_name.underscore}_subscribed_query_' + current_user.id,
+                data['query'] + '/////' + data['store'] + '/////' + data['scope'],
+                data['variables']
+              )
             end
 
-            def options_for_execute(data)
-              query = data['query']
-              variables = ensure_hash(data['variables'])
-              operation_name = data['operationName']
-              context = { current_user: current_user, channel: self }.
-                        merge(ensure_hash(data['context']).symbolize_keys). # ensure context is filled
-                        merge(variables) # include variables in context too
-              [query, context, variables, operation_name]
+            def unsubscribe_to_query(data)
+              Redis.current.hdel(
+                '#{Rails.application.class.parent_name.underscore}_subscribed_query_' + current_user.id,
+                data['query'] + '/////' + data['store']
+              )
             end
 
-            # Handle form data, JSON body, or a blank value
-            def ensure_hash(ambiguous_param)
-              case ambiguous_param
-              when String
-                ambiguous_param.present? ? ensure_hash(JSON.parse(ambiguous_param)) : {}
-              when Hash, ActionController::Parameters
-                ambiguous_param
-              when nil
-                {}
-              else
-                raise ArgumentError, 'Unexpected parameter: ' + ambiguous_param
+            def unsubscribed
+              Redis.current.hset('#{Rails.application.class.parent_name.underscore}_online_users', current_user.id, '0')
+              Redis.current.hdel('#{Rails.application.class.parent_name.underscore}_subscribed_query_' + current_user.id, current_user.id)
+              User.online.each do |user|
+                OnlineUsersChannel.broadcast_to(user, User.online_user_ids)
               end
             end
 
           end
+
         STRING
       )
     end
@@ -347,7 +371,7 @@ module GraphqlRailsApi
             attr_accessor :params, :object, :fields, :user
 
             def initialize(params: {}, object: nil, object_id: nil, user: nil, context: nil)
-              @params = params.to_h.symbolize_keys
+              @params = params.is_a?(Array) ? params.map { |p| p.to_h.symbolize_keys } : params.to_h.symbolize_keys
               @context = context
               @object = object || (object_id && model.visible_for(user: user).find_by(id: object_id))
               @object_id = object_id
@@ -365,51 +389,76 @@ module GraphqlRailsApi
             end
 
             def index
-              Graphql::HydrateQuery.new(model.all, @context, user: user).run
+              HydrateQuery.new(
+                model.all,
+                @context,
+                order_by: params[:order_by],
+                filter: params[:filter],
+                user: user
+              ).run
             end
 
             def show
-              object = Graphql::HydrateQuery.new(model.all, @context, user: user, id: params[:id]).run
-              return not_allowed if object.blank?
-              object
+              return not_allowed if access_not_allowed
+
+              showed_resource = HydrateQuery.new(model.all, @context, user: user, id: object.id).run
+
+              return not_allowed if showed_resource.blank?
+
+              showed_resource
             end
 
             def create
-              object = model.new(params.select { |p| model.new.respond_to?(p) })
-              if object.save
-                object
+              if user&.action?("can_create_#{singular_resource}")
+                created_resource = model.new(params.select { |p| model.new.respond_to?(p) })
+                return not_allowed if not_allowed_to_create_resource(created_resource)
+
+                created_resource.save ? created_resource : graphql_error(created_resource.errors.full_messages.join(', '))
+              elsif user&.action?("can_create_#{singular_resource}_with_verif")
+                Verification.create(action: 'create', model: model.to_s, params: params, user_id: user.id)
+                graphql_error("Pending verification for a #{singular_resource} creation")
               else
-                graphql_error(object.errors.full_messages.join(', '))
+                not_allowed
               end
             end
 
-            def destroy
-              object = model.find_by(id: params[:id])
+            def update
               return not_allowed if write_not_allowed
-              if object.destroy
-                object
+
+              if user.action?("can_update_#{singular_resource}")
+                object.update_attributes(params) ? object : graphql_error(object.errors.full_messages.join(', '))
+              elsif user.action?("can_update_#{singular_resource}_with_verif")
+                create_update_verification
               else
-                graphql_error(object.errors.full_messages.join(', '))
+                not_allowed
               end
             end
 
-            def update
-              return not_allowed if write_not_allowed
-              if object.update_attributes(params)
-                object
-              else
-                graphql_error(object.errors.full_messages.join(', '))
-              end
+            def destroy
+              return not_allowed if write_not_allowed || !user.action?("can_delete_#{singular_resource}")
+
+              object.destroy ? object : graphql_error(object.errors.full_messages.join(', '))
             end
 
             private
 
+            def create_update_verification
+              Verification.create(
+                action: 'update', model: model.to_s, params: params.merge(id: object.id), user_id: user.id
+              )
+              graphql_error("Pending verification for a #{singular_resource} update")
+            end
+
             def write_not_allowed
-              !model.visible_for(user: user).include?(object) if object
+              return true unless object
+
+              !model.writable_for(user: user).pluck(:id).include?(object.id)
             end
 
             def access_not_allowed
-              !model.visible_for(user: user).include?(object) if object
+              return true unless object
+
+              !model.visible_for(user: user).pluck(:id).include?(object.id)
             end
 
             def not_allowed
@@ -432,8 +481,23 @@ module GraphqlRailsApi
               self.class.to_s.split(':').first.underscore
             end
 
+            def not_allowed_to_create_resource(created_resource)
+              params.select { |k, _| k.to_s.end_with?('_id') }.each do |belongs_relation, rel_id|
+                klass = created_resource.class.reflect_on_association(belongs_relation.to_s.gsub('_id', '')).klass
+                return true if rel_id.present? && !klass.visible_for(user: user).pluck(:id).include?(rel_id)
+              end
+
+              params.select { |k, _| k.to_s.end_with?('_ids') }.each do |many_relation, rel_ids|
+                klass = created_resource.class.reflect_on_association(many_relation.to_s.gsub('_ids', '').pluralize).klass
+                ids = klass.visible_for(user: user).pluck(:id)
+                rel_ids.each { |id| return true if id.present? && !ids.include?(id) }
+              end
+              false
+            end
+
           end
 
+
         STRING
       )
     end

data/lib/generators/graphql_resource/graphql_resource_generator.rb

@@ -1,12 +1,15 @@
 class GraphqlResourceGenerator < Rails::Generators::NamedBase
 
-  %i[migration model mutations service graphql_input_type graphql_type propagation migrate].each do |opt|
+  %i[
+    migration model mutations service graphql_input_type
+    graphql_type propagation connection migrate
+  ].each do |opt|
     class_option(opt, type: :boolean, default: true)
   end
 
   TYPES_MAPPING = {
-    'id' => '!types.ID',
-    'uuid' => '!types.String',
+    'id' => 'types.ID',
+    'uuid' => 'types.String',
     'boolean' => 'types.Boolean',
     'float' => 'types.Float',
     'decimal' => 'types.Float',
@@ -16,6 +19,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
 
   def create_graphql_files
     return if args.blank?
+
     parse_args
 
     # Generate migration
@@ -27,6 +31,9 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     # Graphql Type
     generate_graphql_type(@resource) if options.graphql_type?
 
+    # Graphql Connection
+    generate_graphql_connection(@resource) if options.connection?
+
     # Model
     generate_model(@resource) if options.model?
 
@@ -44,16 +51,16 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
   private
 
   def types_mapping(type)
-    TYPES_MAPPING[type] || "types.String"
+    TYPES_MAPPING[type] || 'types.String'
   end
 
   def parse_args
     if Graphql::Rails::Api::Config.instance.id_type == :uuid
       @id_db_type = 'uuid'
-      @id_type = '!types.String'
+      @id_type = 'types.String'
     else
       @id_db_type = 'integer'
-      @id_type = '!types.ID'
+      @id_type = 'types.ID'
     end
 
     @resource = file_name.singularize
@@ -64,6 +71,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
 
     @args = args.each_with_object({}) do |f, hash|
       next if f.split(':').count != 2
+
       case f.split(':').first
       when 'belongs_to' then
         hash["#{f.split(':').last.singularize}_id"] = @id_db_type
@@ -110,6 +118,21 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     generate_graphql_input_type(resource) if options.graphql_input_type?
   end
 
+  def generate_graphql_connection(resource)
+    File.write(
+      "#{graphql_resource_directory(resource)}/connection.rb",
+      <<~STRING
+        #{resource_class(resource)}::Connection = #{resource.pluralize.camelize}::Type.define_connection do
+          name '#{resource.camelize}Connection'
+
+          field :total_count, types.Int do
+            resolve ->(obj, _, _) { obj.nodes.count }
+          end
+        end
+      STRING
+    )
+  end
+
   def generate_graphql_input_type(resource)
     system("mkdir -p #{@mutations_directory}")
     File.write(
@@ -132,7 +155,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
       <<~STRING
         #{resource_class(resource)}::Type = GraphQL::ObjectType.define do
           name '#{resource_class(resource).singularize}'
-          field :id, #{@id_type}
+          field :id, !#{@id_type}
           field :created_at, types.String
           field :updated_at, types.String
           #{map_types(input_type: false)}
@@ -148,14 +171,16 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
   def add_has_many_fields_to_type(field, resource)
     file_name = "app/graphql/#{field.pluralize}/type.rb"
     if File.read(file_name).include?("field :#{resource.singularize}_ids") ||
-        File.read(file_name).include?("field :#{resource.pluralize}")
+        File.read(file_name).include?("field :#{resource.pluralize}") ||
+        File.read(file_name).include?("connection :#{resource.pluralize}_connection")
       return
     end
     write_at(
       file_name, 4,
       <<-STRING
-  field :#{resource.singularize}_ids, !types[#{@id_type}]
-  field :#{resource.pluralize}, !types[!#{resource.pluralize.camelize}::Type]
+  field :#{resource.singularize}_ids, types[#{@id_type}]
+  field :#{resource.pluralize}, types[#{resource.pluralize.camelize}::Type]
+  connection :#{resource.pluralize}_connection, #{resource.pluralize.camelize}::Connection
         STRING
     )
 
@@ -167,7 +192,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     write_at(
       input_type_file_name, 4,
       <<-STRING
-  argument :#{resource.singularize}_ids, !types[#{@id_type}]
+  argument :#{resource.singularize}_ids, types[#{@id_type}]
       STRING
     )
 
@@ -179,11 +204,12 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
         File.read(file_name).include?("field :#{field.singularize}")
       return
     end
+
     write_at(
       file_name, 4,
       <<-STRING
   field :#{field.singularize}_id, #{@id_type}
-  field :#{field.singularize}, !#{field.pluralize.camelize}::Type
+  field :#{field.singularize}, #{field.pluralize.camelize}::Type
       STRING
     )
     input_type_file_name = "app/graphql/#{resource.pluralize}/mutations/input_type.rb"
@@ -191,6 +217,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
         File.read(input_type_file_name).include?("argument :#{field.singularize}")
       return
     end
+
     write_at(
       input_type_file_name, 4,
       <<-STRING
@@ -275,7 +302,7 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
       res = "#{input_type ? 'argument' : 'field'} :#{field_name}, #{field_type}"
       if !input_type && field_name.ends_with?('_id') && @belongs_to_fields.key?(field_name)
         res += "\n  field :#{field_name.gsub('_id', '')}, " \
-          "!#{field_name.gsub('_id', '').pluralize.camelize}::Type"
+          "#{field_name.gsub('_id', '').pluralize.camelize}::Type"
       end
       res
     end&.join("\n  ")

data/lib/graphql/hydrate_query.rb

@@ -1,10 +1,13 @@
 require 'deep_pluck'
+require 'rkelly'
 
 module Graphql
   class HydrateQuery
 
-    def initialize(model, context, check_visibility: true, id: nil, user: nil)
-      @fields = context&.irep_node&.scoped_children&.values&.first
+    def initialize(model, context, order_by: nil, filter: nil, check_visibility: true, id: nil, user: nil)
+      @context = context
+      @filter = filter
+      @order_by = order_by
       @model = model
       @models = [model_name.singularize.camelize]
       @check_visibility = check_visibility
@@ -13,12 +16,19 @@ module Graphql
     end
 
     def run
+      @model = @model.where(transform_filter(@filter)) if @filter
+      @model = @model.order(@order_by) if @order_by
       @model = @model.where(id: @id) if @id
-      plucked = @model.deep_pluck(*hash_to_array_of_hashes(fields_to_hash(@fields), @model))
+      plucked = @model.deep_pluck(*hash_to_array_of_hashes(parse_fields(@context&.irep_node), @model))
       result = plucked_attr_to_structs(plucked, model_name.singularize.camelize.constantize)&.compact
       @id ? result.first : result
     end
 
+    def transform_filter(filter)
+      parsed_filter = RKelly::Parser.new.parse(filter).to_ecma
+      parsed_filter.gsub('||', 'OR').gsub('&&', 'AND').gsub('===', '=').gsub('==', '=').delete(';')
+    end
+
     def plucked_attr_to_structs(arr, parent_model)
       arr.map { |e| hash_to_struct(e, parent_model) }
     end
@@ -49,7 +59,7 @@ module Graphql
     end
 
     def hash_to_array_of_hashes(hash, parent_class)
-      return if parent_class.nil?
+      return if parent_class.nil? || hash.nil?
 
       hash['id'] = nil if hash['id'].blank?
       fetch_ids_from_relation(hash)
@@ -87,14 +97,21 @@ module Graphql
       child_class_name = child.to_s.singularize.camelize
       parent_class_name = parent.to_s.singularize.camelize
       return child_class_name.constantize if activerecord_model?(child_class_name)
+
       return unless activerecord_model?(parent_class_name)
 
       parent_class_name.constantize.reflections[child.to_s.underscore]&.klass
     end
 
-    def fields_to_hash(fields)
+    def parse_fields(irep_node)
+      fields = irep_node&.scoped_children&.values&.first
+      if fields.key?('edges')
+        fields = fields['edges'].scoped_children.values.first['node']&.scoped_children&.values&.first
+      end
+      return if fields.blank?
+
       fields.each_with_object({}) do |(k, v), h|
-        h[k] = v.scoped_children == {} ? nil : fields_to_hash(v.scoped_children.values.first)
+        h[k] = v.scoped_children == {} ? nil : parse_fields(v)
       end
     end
 

data/lib/graphql/rails/api/config.rb

@@ -4,7 +4,7 @@ module Graphql
       class Config
 
         include Singleton
-        attr_accessor :id_type, :basic_mutations
+        attr_accessor :id_type
 
         def self.query_resources
           Dir.glob("#{File.expand_path('.')}/app/graphql/*/type.rb").map do |dir|

data/lib/graphql/rails/api/version.rb

@@ -1,7 +1,7 @@
 module Graphql
   module Rails
     module Api
-      VERSION = '0.5.0'.freeze
+      VERSION = '0.6.0'.freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-api
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - poilon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-13 00:00:00.000000000 Z
+date: 2018-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -64,6 +64,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: rkelly-remix
+  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'
 description: This gem purpose is to make graphql easier to use in ruby. Mainly developed
   for from-scratch app
 email: