graphql-client 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 682f2fda3a85b90c7f7ebe9ff03c6c3b8a6853e3
-  data.tar.gz: 85ad7663333b37fc0e7407254211b88ea670dab6
+  metadata.gz: 54d0c609ffe31a1375380c8647fe4a1502f19a76
+  data.tar.gz: 57dc7311a2da955fa6a7297aa383eacf7473bee6
 SHA512:
-  metadata.gz: 8df3fe212b2ae0ba9ed43b26b326a40d54e5de231bd1958cd1538cdf5fef6d4cf65743938c73310bc84523f053e2ac4cd4a8da90c5015cf1d9195215d261d74e
-  data.tar.gz: 0e0fa5380ae41b37113927d592ccdb39e03f586a2a07155e590963b2c4d07a1c5048e83357aadfa0c7ecd0e8e7cfeba130ec4d1cbfd4ebf0a9766733151e1fdb
+  metadata.gz: 645186f0b676ade5ec368fe51c0a0fc97110fb6d100eb08411b8f079b8e793c5837c94bde44d44a4ec119fe40593ddce826c943a3ee660635e4c8899dbcdfdcd
+  data.tar.gz: ad0e699625c3f34dfec487284e94ca6a4e4dc31b2522f4a7909a162f9d7db6d27d42873b6a057e3b95158027a93f9eb3708dd3f12535a2d51f0da3fa1604a31c

data/README.md

@@ -94,7 +94,7 @@ end
 
 ### Executing queries
 
-Pass the reference of a parsed query definition to `GraphQL::Client#query`. Data is returned back in a wrapped `GraphQL::QueryResult` struct that provides Ruby-ish accessors.
+Pass the reference of a parsed query definition to `GraphQL::Client#query`. Data is returned back in a wrapped `GraphQL::Client::Schema::ObjectType` struct that provides Ruby-ish accessors.
 
 ``` ruby
 result = SWAPI::Client.query(Hero::Query)

data/lib/graphql/client.rb

@@ -9,9 +9,9 @@ require "graphql/client/error"
 require "graphql/client/errors"
 require "graphql/client/fragment_definition"
 require "graphql/client/operation_definition"
-require "graphql/client/query_result"
 require "graphql/client/query_typename"
 require "graphql/client/response"
+require "graphql/client/schema"
 require "graphql/language/nodes/deep_freeze_ext"
 require "json"
 
@@ -31,6 +31,8 @@ module GraphQL
 
     attr_reader :schema, :execute
 
+    attr_reader :types
+
     attr_accessor :document_tracking_enabled
 
     # Public: Check if collocated caller enforcement is enabled.
@@ -89,6 +91,8 @@ module GraphQL
       @document_tracking_enabled = false
       @allow_dynamic_queries = false
       @enforce_collocated_callers = enforce_collocated_callers
+
+      @types = Schema.generate(@schema)
     end
 
     def parse(str, filename = nil, lineno = nil)
@@ -146,6 +150,9 @@ module GraphQL
 
       doc = GraphQL.parse(str)
 
+      document_types = DocumentTypes.analyze_types(self.schema, doc).freeze
+      QueryTypename.insert_typename_fields(doc, types: document_types)
+
       doc.definitions.each do |node|
         node.name ||= "__anonymous__"
       end
@@ -168,21 +175,24 @@ module GraphQL
         raise error
       end
 
-      document_types = DocumentTypes.analyze_types(self.schema, doc).freeze
-
-      QueryTypename.insert_typename_fields(doc, types: document_types)
-
       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
+
         node.name = nil if node.name == "__anonymous__"
         sliced_document = Language::DefinitionSlice.slice(document_dependencies, node.name)
         definition = Definition.for(
-          schema: self.schema,
-          node: node,
+          client: self,
+          irep_node: irep_node,
           document: sliced_document,
-          document_types: document_types,
-          source_location: source_location,
-          enforce_collocated_callers: enforce_collocated_callers
+          source_location: source_location
         )
         definitions[node.name] = definition
       end

data/lib/graphql/client/definition.rb

@@ -1,4 +1,11 @@
 # frozen_string_literal: true
+
+require "graphql"
+require "graphql/client/collocated_enforcement"
+require "graphql/client/schema/object_type"
+require "graphql/client/schema/possible_types"
+require "set"
+
 module GraphQL
   class Client
     # Definitions are constructed by Client.parse and wrap a parsed AST of the
@@ -7,31 +14,48 @@ module GraphQL
     #
     # Definitions MUST be assigned to a constant.
     class Definition < Module
-      def self.for(node:, **kargs)
-        case node
+      def self.for(irep_node:, **kargs)
+        case irep_node.ast_node
         when Language::Nodes::OperationDefinition
-          OperationDefinition.new(node: node, **kargs)
+          OperationDefinition.new(irep_node: irep_node, **kargs)
         when Language::Nodes::FragmentDefinition
-          FragmentDefinition.new(node: node, **kargs)
+          FragmentDefinition.new(irep_node: irep_node, **kargs)
         else
-          raise TypeError, "expected node to be a definition type, but was #{node.class}"
+          raise TypeError, "expected node to be a definition type, but was #{irep_node.ast_node.class}"
         end
       end
 
-      def initialize(node:, document:, schema:, document_types:, source_location:, enforce_collocated_callers:)
-        @definition_node = node
+      def initialize(client:, document:, irep_node:, source_location:)
+        @client = client
         @document = document
-        @schema = schema
-        @document_types = document_types
+        @definition_irep_node = irep_node
         @source_location = source_location
-        @enforce_collocated_callers = enforce_collocated_callers
+        @schema_class = client.types.define_class(self, definition_irep_node, definition_irep_node.return_type)
       end
 
+      # Internal: Get associated owner GraphQL::Client instance.
+      attr_reader :client
+
+      # Internal root schema class for defintion. Returns
+      # GraphQL::Client::Schema::ObjectType or
+      # GraphQL::Client::Schema::PossibleTypes.
+      attr_reader :schema_class
+
+      # Deprecated: Use schema_class
+      alias_method :type, :schema_class
+
+      # Internal: Get underlying IRep Node for the definition.
+      #
+      # Returns GraphQL::InternalRepresentation::Node object.
+      attr_reader :definition_irep_node
+
       # Internal: Get underlying operation or fragment defintion AST node for
       # definition.
       #
       # Returns OperationDefinition or FragmentDefinition object.
-      attr_reader :definition_node
+      def definition_node
+        definition_irep_node.ast_node
+      end
 
       # Public: Global name of definition in client document.
       #
@@ -57,27 +81,96 @@ module GraphQL
       # and any FragmentDefinition dependencies.
       attr_reader :document
 
-      # Internal: Mapping of document nodes to schema types.
-      attr_reader :document_types
-
-      attr_reader :schema
-
       # Public: Returns the Ruby source filename and line number containing this
       # definition was not defined in Ruby.
       #
       # Returns Array pair of [String, Fixnum].
       attr_reader :source_location
 
-      attr_reader :enforce_collocated_callers
-
-      def new(*args)
-        type.new(*args)
+      def new(obj, errors = Errors.new)
+        case schema_class
+        when GraphQL::Client::Schema::PossibleTypes
+          case obj
+          when NilClass
+            nil
+          else
+            schema_class.cast(obj.to_h, obj.errors)
+          end
+        when GraphQL::Client::Schema::ObjectType
+          case obj
+          when NilClass, schema_class
+            obj
+          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
+          end
+        else
+          raise TypeError, "unexpected #{schema_class}"
+        end
       end
 
-      def type
-        # TODO: Fix type indirection
-        @type ||= GraphQL::Client::QueryResult.wrap(self, definition_node, document_types[definition_node], name: "#{name}.type")
+      # Internal: Nodes AST indexes.
+      def indexes
+        @indexes ||= begin
+          visitor = GraphQL::Language::Visitor.new(document)
+          definitions = index_node_definitions(visitor)
+          spreads = index_spreads(visitor)
+          visitor.visit
+          { definitions: definitions, spreads: spreads }
+        end
       end
+
+      private
+        def index_spreads(visitor)
+          spreads = {}
+          on_node = ->(node, _parent) { spreads[node] = Set.new(flatten_spreads(node).map(&:name)) }
+
+          visitor[GraphQL::Language::Nodes::Field] << on_node
+          visitor[GraphQL::Language::Nodes::FragmentDefinition] << on_node
+          visitor[GraphQL::Language::Nodes::OperationDefinition] << on_node
+
+          spreads
+        end
+
+        def flatten_spreads(node)
+          node.selections.flat_map do |selection|
+            case selection
+            when Language::Nodes::FragmentSpread
+              selection
+            when Language::Nodes::InlineFragment
+              flatten_spreads(selection)
+            else
+              []
+            end
+          end
+        end
+
+        def index_node_definitions(visitor)
+          current_definition = nil
+          enter_definition = ->(node, _parent) { current_definition = node }
+          leave_definition = ->(node, _parent) { current_definition = nil }
+
+          visitor[GraphQL::Language::Nodes::FragmentDefinition].enter << enter_definition
+          visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << leave_definition
+          visitor[GraphQL::Language::Nodes::OperationDefinition].enter << enter_definition
+          visitor[GraphQL::Language::Nodes::OperationDefinition].leave << leave_definition
+
+          definitions = {}
+          on_node = ->(node, _parent) { definitions[node] = current_definition }
+          visitor[GraphQL::Language::Nodes::Field] << on_node
+          visitor[GraphQL::Language::Nodes::FragmentDefinition] << on_node
+          visitor[GraphQL::Language::Nodes::InlineFragment] << on_node
+          visitor[GraphQL::Language::Nodes::OperationDefinition] << on_node
+          definitions
+        end
     end
   end
 end

data/lib/graphql/client/deprecation.rb

@@ -4,7 +4,7 @@ require "active_support/deprecation"
 module GraphQL
   class Client
     if ActiveSupport::Deprecation.is_a?(Class)
-      Deprecation = ActiveSupport::Deprecation.new("0.9", "graphql-client")
+      Deprecation = ActiveSupport::Deprecation.new("11.0", "graphql-client")
     else
       module Deprecation
         extend self
@@ -22,7 +22,7 @@ module GraphQL
         end
 
         def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
-          warn "#{deprecated_method_name} is deprecated and will be removed from graphql-client 0.9 (#{message})"
+          warn "#{deprecated_method_name} is deprecated and will be removed from graphql-client 0.11 (#{message})"
         end
       end
     end

data/lib/graphql/client/document_types.rb

@@ -39,6 +39,9 @@ module GraphQL
         end
         visitor.visit
 
+        fields
+      rescue StandardError
+        # FIXME: TypeStack my crash on invalid documents
         fields
       end
     end

data/lib/graphql/client/error.rb

@@ -5,6 +5,9 @@ module GraphQL
     class Error < StandardError
     end
 
+    class InvariantError < Error
+    end
+
     class ImplicitlyFetchedFieldError < NoMethodError
     end
 

data/lib/graphql/client/response.rb

@@ -7,11 +7,11 @@ module GraphQL
     #
     #   https://facebook.github.io/graphql/#sec-Response-Format
     class Response
-      # Public: Wrapped QueryResult of data returned from the server.
+      # Public: Wrapped ObjectType of data returned from the server.
       #
       #   https://facebook.github.io/graphql/#sec-Data
       #
-      # Returns instance of QueryResult subclass.
+      # Returns instance of ObjectType subclass.
       attr_reader :data
 
       # Public: Get partial failures from response.

data/lib/graphql/client/schema.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "graphql"
+require "graphql/client/schema/enum_type"
+require "graphql/client/schema/include_directive"
+require "graphql/client/schema/interface_type"
+require "graphql/client/schema/list_type"
+require "graphql/client/schema/non_null_type"
+require "graphql/client/schema/object_type"
+require "graphql/client/schema/scalar_type"
+require "graphql/client/schema/skip_directive"
+require "graphql/client/schema/union_type"
+
+module GraphQL
+  class Client
+    module Schema
+      module ClassMethods
+        def define_class(definition, irep_node, type)
+          type_klass = case type
+          when GraphQL::NonNullType
+            define_class(definition, irep_node, type.of_type).to_non_null_type
+          when GraphQL::ListType
+            define_class(definition, irep_node, type.of_type).to_list_type
+          else
+            const_get(type.name).define_class(definition, irep_node)
+          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
+            end
+          end
+        end
+      end
+
+      def self.generate(schema)
+        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?("__")
+          if klass = class_for(schema, type, cache)
+            klass.schema_module = mod
+            mod.const_set(name, klass)
+          end
+        end
+
+        directives = {}
+        mod.define_singleton_method(:directives) { directives }
+        directives[:include] = IncludeDirective
+        directives[:skip] = SkipDirective
+
+        mod
+      end
+
+      def self.class_for(schema, type, cache)
+        return cache[type] if cache[type]
+
+        case type
+        when GraphQL::InputObjectType
+          nil
+        when GraphQL::ScalarType
+          cache[type] = ScalarType.new(type)
+        when GraphQL::EnumType
+          cache[type] = EnumType.new(type)
+        when GraphQL::ListType
+          cache[type] = class_for(schema, type.of_type, cache).to_list_type
+        when GraphQL::NonNullType
+          cache[type] = class_for(schema, type.of_type, cache).to_non_null_type
+        when GraphQL::UnionType
+          klass = cache[type] = UnionType.new(type)
+
+          type.possible_types.each do |possible_type|
+            possible_klass = class_for(schema, possible_type, cache)
+            possible_klass.send :include, klass
+          end
+
+          klass
+        when GraphQL::InterfaceType
+          cache[type] = InterfaceType.new(type)
+        when GraphQL::ObjectType
+          klass = cache[type] = ObjectType.new(type)
+
+          type.interfaces.each do |interface|
+            klass.send :include, class_for(schema, interface, cache)
+          end
+
+          type.all_fields.each do |field|
+            klass.fields[field.name.to_sym] = class_for(schema, field.type, cache)
+          end
+
+          klass
+        else
+          raise TypeError, "unexpected #{type.class}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Client
+    module Schema
+      module BaseType
+        # Public: Get associated GraphQL::BaseType with for this class.
+        attr_reader :type
+
+        # Internal: Get owner schema Module container.
+        attr_accessor :schema_module
+
+        # Internal: Cast JSON value to wrapped value.
+        #
+        # value - JSON value
+        # errors - Errors instance
+        #
+        # Returns BaseType instance.
+        def cast(value, errors)
+          raise NotImplementedError, "subclasses must implement #cast(value, errors)"
+        end
+
+        # Internal: Get non-nullable wrapper of this type class.
+        #
+        # Returns NonNullType instance.
+        def to_non_null_type
+          @null_type ||= NonNullType.new(self)
+        end
+
+        # Internal: Get list wrapper of this type class.
+        #
+        # Returns ListType instance.
+        def to_list_type
+          @list_type ||= ListType.new(self)
+        end
+      end
+    end
+  end
+end