graphql-client 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 342aa95830be1c53716c72962fad3c3785058f160404fba1aa603f9b94a96f92
-  data.tar.gz: c63ff270ab64ad1ee8a8ece5a36d20be9b12e138e86cc0a4eb88246bf2d4c2bb
+  metadata.gz: 1f7ced5b5ef5fb8e496d8c221867165c4629670a5f8ecf1e44f8c523e5774ae2
+  data.tar.gz: 49453ec41a714dca5774c32b24139527beb7623a8c99a2368e789f9b1443c79a
 SHA512:
-  metadata.gz: a701d2ad7b0776f43d04b63fa394d5470fe7f5a8d0d71467affd78d04069ec212249fc1e0ab9c86d82bdabadc750ac6eb63b7e6c77d3b842f82f5c6c88d81baf
-  data.tar.gz: 3033fcb57a59f3518436f0f903154f9eaaa070230afd6ba4f83d3c6c42904f71a503f92f42aa5b91932770c15bb8551a5ea7ce7130a9bf8ac7eca11756ef53ce
+  metadata.gz: b69902cbed392a6ad77d5e124db8196439b17750ecb369fc3189a93593857f5e1cf80ade820edb5abc0e11cade056832c733726e2e4202207496d7435eb6ebfa
+  data.tar.gz: a918d43558b2f75ce3627a7dd003ba76e083b9c087f15c36e4df7e571d5eef71a4760fe929a7d6d93eb78a22b4f310c8ef75f9737a719a516c659eb70117026e

data/README.md

@@ -1,9 +1,18 @@
-# graphql-client
+# graphql-client [![Gem Version](https://badge.fury.io/rb/graphql-client.svg)](https://badge.fury.io/rb/graphql-client) [![Build Status](https://travis-ci.org/github/graphql-client.svg?branch=master)](https://travis-ci.org/github/graphql-client)
 
 GraphQL Client is a Ruby library for declaring, composing and executing GraphQL queries.
 
 ## Usage
 
+### Installation
+
+Add `graphql-client` to your Gemfile and then run `bundle install`.
+
+```ruby
+# Gemfile
+gem 'graphql-client'
+```
+
 ### Configuration
 
 Sample configuration for a GraphQL Client to query from the [SWAPI GraphQL Wrapper](https://github.com/graphql/swapi-graphql).

data/lib/graphql/client.rb

@@ -12,8 +12,8 @@ require "graphql/client/operation_definition"
 require "graphql/client/query_typename"
 require "graphql/client/response"
 require "graphql/client/schema"
-require "graphql/language/nodes/deep_freeze_ext"
 require "json"
+require "delegate"
 
 module GraphQL
   # GraphQL Client helps build and execute queries against a GraphQL backend.
@@ -67,9 +67,9 @@ module GraphQL
       end
     end
 
-    IntrospectionDocument = GraphQL.parse(GraphQL::Introspection::INTROSPECTION_QUERY).deep_freeze
+    IntrospectionDocument = GraphQL.parse(GraphQL::Introspection::INTROSPECTION_QUERY)
 
-    def self.dump_schema(schema, io = nil)
+    def self.dump_schema(schema, io = nil, context: {})
       unless schema.respond_to?(:execute)
         raise TypeError, "expected schema to respond to #execute(), but was #{schema.class}"
       end
@@ -78,7 +78,7 @@ module GraphQL
         document: IntrospectionDocument,
         operation_name: "IntrospectionQuery",
         variables: {},
-        context: {}
+        context: context
       ).to_h
 
       if io
@@ -202,19 +202,10 @@ module GraphQL
 
       definitions = {}
       doc.definitions.each do |node|
-        irep_node = case node
-        when GraphQL::Language::Nodes::OperationDefinition
-          errors[:irep].operation_definitions[node.name]
-        when GraphQL::Language::Nodes::FragmentDefinition
-          errors[:irep].fragment_definitions[node.name]
-        else
-          raise TypeError, "unexpected #{node.class}"
-        end
-
         sliced_document = Language::DefinitionSlice.slice(document_dependencies, node.name)
         definition = Definition.for(
           client: self,
-          irep_node: irep_node,
+          ast_node: node,
           document: sliced_document,
           source_document: doc,
           source_location: source_location
@@ -229,10 +220,6 @@ module GraphQL
       visitor[Language::Nodes::FragmentSpread].leave << name_hook.method(:rename_node)
       visitor.visit
 
-      if !doc.respond_to?(:merge)
-        doc.deep_freeze # 1.9 introduced immutable AST nodes, so we skip this on 1.9+
-      end
-
       if document_tracking_enabled
         if @document.respond_to?(:merge) # GraphQL 1.9+
           @document = @document.merge(definitions: @document.definitions + doc.definitions)
@@ -261,7 +248,7 @@ module GraphQL
         definition = @definitions[node.name]
         if definition
           node.extend(LazyName)
-          node.name_proc = -> { definition.definition_name }
+          node._definition = definition
         end
       end
     end
@@ -384,10 +371,10 @@ module GraphQL
     # name to point to a lazily defined Proc instead of a static string.
     module LazyName
       def name
-        @name_proc.call
+        @_definition.definition_name
       end
 
-      attr_writer :name_proc
+      attr_writer :_definition
     end
 
     private

data/lib/graphql/client/definition.rb

@@ -14,24 +14,46 @@ module GraphQL
     #
     # Definitions MUST be assigned to a constant.
     class Definition < Module
-      def self.for(irep_node:, **kargs)
-        case irep_node.ast_node
+      def self.for(ast_node:, **kargs)
+        case ast_node
         when Language::Nodes::OperationDefinition
-          OperationDefinition.new(irep_node: irep_node, **kargs)
+          OperationDefinition.new(ast_node: ast_node, **kargs)
         when Language::Nodes::FragmentDefinition
-          FragmentDefinition.new(irep_node: irep_node, **kargs)
+          FragmentDefinition.new(ast_node: ast_node, **kargs)
         else
-          raise TypeError, "expected node to be a definition type, but was #{irep_node.ast_node.class}"
+          raise TypeError, "expected node to be a definition type, but was #{ast_node.class}"
         end
       end
 
-      def initialize(client:, document:, source_document:, irep_node:, source_location:)
+      def initialize(client:, document:, source_document:, ast_node:, source_location:)
         @client = client
         @document = document
         @source_document = source_document
-        @definition_node = irep_node.ast_node
+        @definition_node = ast_node
         @source_location = source_location
-        @schema_class = client.types.define_class(self, irep_node, irep_node.return_type)
+
+        definition_type = case ast_node
+        when GraphQL::Language::Nodes::OperationDefinition
+          case ast_node.operation_type
+          when "mutation"
+            @client.schema.mutation
+          when "subscription"
+            @client.schema.subscription
+          when "query", nil
+            @client.schema.query
+          else
+            raise "Unexpected operation_type: #{ast_node.operation_type}"
+          end
+        when GraphQL::Language::Nodes::FragmentDefinition
+          @client.schema.types[ast_node.type.name]
+        else
+          raise "Unexpected ast_node: #{ast_node}"
+        end
+
+        @schema_class = client.types.define_class(self, [ast_node], definition_type)
+
+        # Clear cache only needed during initialization
+        @indexes = nil
       end
 
       # Internal: Get associated owner GraphQL::Client instance.
@@ -89,9 +111,9 @@ module GraphQL
         when GraphQL::Client::Schema::PossibleTypes
           case obj
           when NilClass
-            nil
+            obj
           else
-            schema_class.cast(obj.to_h, obj.errors)
+            cast_object(obj)
           end
         when GraphQL::Client::Schema::ObjectType
           case obj
@@ -100,14 +122,7 @@ module GraphQL
           when Hash
             schema_class.new(obj, errors)
           else
-            if obj.class.is_a?(GraphQL::Client::Schema::ObjectType)
-              unless obj.class._spreads.include?(definition_node.name)
-                raise TypeError, "#{definition_node.name} is not included in #{obj.class.source_definition.name}"
-              end
-              schema_class.cast(obj.to_h, obj.errors)
-            else
-              raise TypeError, "unexpected #{obj.class}"
-            end
+            cast_object(obj)
           end
         else
           raise TypeError, "unexpected #{schema_class}"
@@ -126,9 +141,26 @@ module GraphQL
       end
 
       private
+
+        def cast_object(obj)
+          if obj.class.is_a?(GraphQL::Client::Schema::ObjectType)
+            unless obj.class._spreads.include?(definition_node.name)
+              raise TypeError, "#{definition_node.name} is not included in #{obj.class.source_definition.name}"
+            end
+            schema_class.cast(obj.to_h, obj.errors)
+          else
+            raise TypeError, "unexpected #{obj.class}"
+          end
+        end
+
+        EMPTY_SET = Set.new.freeze
+
         def index_spreads(visitor)
           spreads = {}
-          on_node = ->(node, _parent) { spreads[node] = Set.new(flatten_spreads(node).map(&:name)) }
+          on_node = ->(node, _parent) do
+            node_spreads = flatten_spreads(node).map(&:name)
+            spreads[node] = node_spreads.empty? ? EMPTY_SET : Set.new(node_spreads).freeze
+          end
 
           visitor[GraphQL::Language::Nodes::Field] << on_node
           visitor[GraphQL::Language::Nodes::FragmentDefinition] << on_node

data/lib/graphql/client/schema.rb

@@ -15,23 +15,25 @@ module GraphQL
   class Client
     module Schema
       module ClassMethods
-        def define_class(definition, irep_node, type)
-          type_klass = case type
+        def define_class(definition, ast_nodes, type)
+          type_class = case type
           when GraphQL::NonNullType
-            define_class(definition, irep_node, type.of_type).to_non_null_type
+            define_class(definition, ast_nodes, type.of_type).to_non_null_type
           when GraphQL::ListType
-            define_class(definition, irep_node, type.of_type).to_list_type
+            define_class(definition, ast_nodes, type.of_type).to_list_type
           else
-            get_class(type.name).define_class(definition, irep_node)
+            get_class(type.name).define_class(definition, ast_nodes)
           end
 
-          irep_node.ast_node.directives.inject(type_klass) do |klass, directive|
-            if directive = self.directives[directive.name.to_sym]
-              directive.new(klass)
-            else
-              klass
+          ast_nodes.each do |ast_node|
+            ast_node.directives.each do |directive|
+              if directive = self.directives[directive.name.to_sym]
+                type_class = directive.new(type_class)
+              end
             end
           end
+
+          type_class
         end
 
         def get_class(type_name)
@@ -50,6 +52,13 @@ module GraphQL
           const_set(class_name, klass)
         end
 
+        DIRECTIVES = { include: IncludeDirective,
+                       skip: SkipDirective }.freeze
+
+        def directives
+          DIRECTIVES
+        end
+
         private
 
         def normalize_type_name(type_name)
@@ -61,10 +70,6 @@ module GraphQL
         mod = Module.new
         mod.extend ClassMethods
 
-        mod.define_singleton_method :schema do
-          schema
-        end
-
         cache = {}
         schema.types.each do |name, type|
           next if name.start_with?("__")
@@ -74,11 +79,6 @@ module GraphQL
           end
         end
 
-        directives = {}
-        mod.define_singleton_method(:directives) { directives }
-        directives[:include] = IncludeDirective
-        directives[:skip] = SkipDirective
-
         mod
       end
 

data/lib/graphql/client/schema/enum_type.rb

@@ -9,6 +9,34 @@ module GraphQL
       class EnumType < Module
         include BaseType
 
+        class EnumValue < String
+          def initialize(obj, enum_value, enum)
+            super(obj)
+            @enum_value = enum_value
+            @enum = enum
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            if method_name[-1] == "?" && @enum.include?(method_name[0..-2])
+              true
+            else
+              super
+            end
+          end
+
+          def method_missing(method_name, *args)
+            if method_name[-1] == "?"
+              queried_value = method_name[0..-2]
+              if @enum.include?(queried_value)
+                raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0)" unless args.empty?
+                return @enum_value == queried_value
+              end
+            end
+
+            super
+          end
+        end
+
         # Internal: Construct enum wrapper from another GraphQL::EnumType.
         #
         # type - GraphQL::EnumType instance
@@ -21,22 +49,18 @@ module GraphQL
           @values = {}
 
           all_values = type.values.keys
+          comparison_set = all_values.map { |s| -s.downcase }.to_set
 
           all_values.each do |value|
-            str = value.dup
-            all_values.each do |v|
-              str.define_singleton_method("#{v.downcase}?") { false }
-            end
-            str.define_singleton_method("#{value.downcase}?") { true }
-            str.freeze
+            str = EnumValue.new(-value, -value.downcase, comparison_set).freeze
             const_set(value, str) if value =~ /^[A-Z]/
-            @values[str] = str
+            @values[str.to_s] = str
           end
 
           @values.freeze
         end
 
-        def define_class(definition, irep_node)
+        def define_class(definition, ast_nodes)
           self
         end
 

data/lib/graphql/client/schema/interface_type.rb

@@ -20,10 +20,12 @@ module GraphQL
           PossibleTypes.new(type, types)
         end
 
-        def define_class(definition, irep_node)
-          new(irep_node.typed_children.keys.map { |ctype|
-            schema_module.get_class(ctype.name).define_class(definition, irep_node)
-          })
+        def define_class(definition, ast_nodes)
+          possible_type_names = definition.client.schema.possible_types(type).map(&:graphql_name)
+          possible_types = possible_type_names.map { |concrete_type_name|
+            schema_module.get_class(concrete_type_name).define_class(definition, ast_nodes)
+          }
+          new(possible_types)
         end
       end
     end

data/lib/graphql/client/schema/object_type.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require "active_support/inflector"
 require "graphql/client/error"
 require "graphql/client/errors"
@@ -20,37 +19,83 @@ module GraphQL
           end
         end
 
-        def define_class(definition, irep_node)
-          fields = irep_node.typed_children[type].inject({}) { |h, (field_name, field_irep_node)|
-            definition_for_field = definition.indexes[:definitions][field_irep_node.ast_node]
-
-            # Ignore fields defined in other documents.
-            if definition.source_document.definitions.include?(definition_for_field)
-              h[field_name.to_sym] = schema_module.define_class(definition, field_irep_node, field_irep_node.definition.type)
+        def define_class(definition, ast_nodes)
+          # First, gather all the ast nodes representing a certain selection, by name.
+          # We gather AST nodes into arrays so that multiple selections can be grouped, for example:
+          #
+          #   {
+          #     f1 { a b }
+          #     f1 { b c }
+          #   }
+          #
+          # should be treated like `f1 { a b c }`
+          field_nodes = {}
+          ast_nodes.each do |ast_node|
+            ast_node.selections.each do |selected_ast_node|
+              gather_selections(field_nodes, definition, selected_ast_node)
             end
-            h
-          }
+          end
 
-          Class.new(self) do
-            define_fields(fields)
+          # After gathering all the nodes by name, prepare to create methods and classes for them.
+          field_classes = {}
+          field_nodes.each do |result_name, field_ast_nodes|
+            # `result_name` might be an alias, so make sure to get the proper name
+            field_name = field_ast_nodes.first.name
+            field_definition = definition.client.schema.get_field(type.name, field_name)
+            field_return_type = field_definition.type
+            field_classes[result_name.to_sym] = schema_module.define_class(definition, field_ast_nodes, field_return_type)
+          end
 
-            if definition.client.enforce_collocated_callers
-              keys = fields.keys.map { |key| ActiveSupport::Inflector.underscore(key) }
-              Client.enforce_collocated_callers(self, keys, definition.source_location[0])
-            end
+          klass = Class.new(self)
+          klass.define_fields(field_classes)
+          klass.instance_variable_set(:@source_definition, definition)
+          klass.instance_variable_set(:@_spreads, definition.indexes[:spreads][ast_nodes.first])
+
+          if definition.client.enforce_collocated_callers
+            keys = field_classes.keys.map { |key| ActiveSupport::Inflector.underscore(key) }
+            Client.enforce_collocated_callers(klass, keys, definition.source_location[0])
+          end
+
+          klass
+        end
+
+        PREDICATE_CACHE = Hash.new { |h, name|
+          h[name] = -> { @data[name] ? true : false }
+        }
 
-            class << self
-              attr_reader :source_definition
-              attr_reader :_spreads
+        METHOD_CACHE = Hash.new { |h, key|
+          h[key] = -> {
+            name = key.to_s
+            type = self.class::FIELDS[key]
+            @casted_data.fetch(name) do
+              @casted_data[name] = type.cast(@data[name], @errors.filter_by_path(name))
             end
+          }
+        }
 
-            @source_definition = definition
-            @_spreads = definition.indexes[:spreads][irep_node.ast_node]
+        MODULE_CACHE = Hash.new do |h, fields|
+          h[fields] = Module.new do
+            fields.each do |name|
+              GraphQL::Client::Schema::ObjectType.define_cached_field(name, self)
+            end
           end
         end
 
+        FIELDS_CACHE = Hash.new { |h, k| h[k] = k }
+
         def define_fields(fields)
-          fields.each { |name, type| define_field(name, type) }
+          const_set :FIELDS, FIELDS_CACHE[fields]
+          mod = MODULE_CACHE[fields.keys.sort]
+          include mod
+        end
+
+        def self.define_cached_field(name, ctx)
+          key = name
+          name = -name.to_s
+          method_name = ActiveSupport::Inflector.underscore(name)
+
+          ctx.send(:define_method, method_name, &METHOD_CACHE[key])
+          ctx.send(:define_method, "#{method_name}?", &PREDICATE_CACHE[name])
         end
 
         def define_field(name, type)
@@ -78,9 +123,67 @@ module GraphQL
             raise InvariantError, "expected value to be a Hash, but was #{value.class}"
           end
         end
+
+        private
+
+        # Given an AST selection on this object, gather it into `fields` if it applies.
+        # If it's a fragment, continue recursively checking the selections on the fragment.
+        def gather_selections(fields, definition, selected_ast_node)
+          case selected_ast_node
+          when GraphQL::Language::Nodes::InlineFragment
+            continue_selection = if selected_ast_node.type.nil?
+              true
+            else
+              schema = definition.client.schema
+              type_condition = schema.types[selected_ast_node.type.name]
+              applicable_types = schema.possible_types(type_condition)
+              # continue if this object type is one of the types matching the fragment condition
+              applicable_types.include?(type)
+            end
+
+            if continue_selection
+              selected_ast_node.selections.each do |next_selected_ast_node|
+                gather_selections(fields, definition, next_selected_ast_node)
+              end
+            end
+          when GraphQL::Language::Nodes::FragmentSpread
+            fragment_definition = definition.document.definitions.find do |defn|
+              defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && defn.name == selected_ast_node.name
+            end
+
+            schema = definition.client.schema
+            type_condition = schema.types[fragment_definition.type.name]
+            applicable_types = schema.possible_types(type_condition)
+            # continue if this object type is one of the types matching the fragment condition
+            continue_selection = applicable_types.include?(type)
+
+            if continue_selection
+              fragment_definition.selections.each do |next_selected_ast_node|
+                gather_selections(fields, definition, next_selected_ast_node)
+              end
+            end
+          when GraphQL::Language::Nodes::Field
+            operation_definition_for_field = definition.indexes[:definitions][selected_ast_node]
+            # Ignore fields defined in other documents.
+            if definition.source_document.definitions.include?(operation_definition_for_field)
+              field_method_name = selected_ast_node.alias || selected_ast_node.name
+              ast_nodes = fields[field_method_name] ||= []
+              ast_nodes << selected_ast_node
+            end
+          else
+            raise "Unexpected selection node: #{selected_ast_node}"
+          end
+        end
       end
 
       class ObjectClass
+        module ClassMethods
+          attr_reader :source_definition
+          attr_reader :_spreads
+        end
+
+        extend ClassMethods
+
         def initialize(data = {}, errors = Errors.new)
           @data = data
           @casted_data = {}

data/lib/graphql/client/schema/scalar_type.rb

@@ -19,7 +19,7 @@ module GraphQL
           @type = type
         end
 
-        def define_class(definition, irep_node)
+        def define_class(definition, ast_nodes)
           self
         end
 

data/lib/graphql/client/schema/union_type.rb

@@ -20,10 +20,12 @@ module GraphQL
           PossibleTypes.new(type, types)
         end
 
-        def define_class(definition, irep_node)
-          new(irep_node.typed_children.keys.map { |ctype|
-            schema_module.get_class(ctype.name).define_class(definition, irep_node)
-          })
+        def define_class(definition, ast_nodes)
+          possible_type_names = definition.client.schema.possible_types(type).map(&:graphql_name)
+          possible_types = possible_type_names.map { |concrete_type_name|
+            schema_module.get_class(concrete_type_name).define_class(definition, ast_nodes)
+          }
+          new(possible_types)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-25 00:00:00.000000000 Z
+date: 2019-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,23 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -51,9 +45,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.22
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -61,9 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.22
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: erubi
   requirement: !ruby/object:Gem::Requirement
@@ -189,7 +177,6 @@ files:
 - lib/graphql/client/schema/skip_directive.rb
 - lib/graphql/client/schema/union_type.rb
 - lib/graphql/client/view_module.rb
-- lib/graphql/language/nodes/deep_freeze_ext.rb
 - lib/rubocop/cop/graphql/heredoc.rb
 - lib/rubocop/cop/graphql/overfetch.rb
 homepage: https://github.com/github/graphql-client
@@ -211,8 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: GraphQL Client

data/lib/graphql/language/nodes/deep_freeze_ext.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require "graphql"
-
-module GraphQL
-  module Language
-    module Nodes
-      # :nodoc:
-      class AbstractNode
-        # Public: Freeze entire Node tree
-        #
-        # Returns self Node.
-        def deep_freeze
-          scalars # load internal state
-          children.each(&:deep_freeze)
-          scalars.each { |s| s && s.freeze }
-          freeze
-          self
-        end
-      end
-    end
-  end
-end