graphql-client 0.16.0 → 0.26.0

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

@@ -3,7 +3,6 @@ require "active_support/inflector"
 require "graphql/client/error"
 require "graphql/client/errors"
 require "graphql/client/schema/base_type"
-require "graphql/client/schema/possible_types"
 
 module GraphQL
   class Client
@@ -16,6 +15,53 @@ module GraphQL
 
             define_singleton_method(:type) { type }
             define_singleton_method(:fields) { fields }
+
+            const_set(:READERS, {})
+            const_set(:PREDICATES, {})
+          end
+        end
+
+        class WithDefinition
+          include BaseType
+          include ObjectType
+
+          EMPTY_SET = Set.new.freeze
+
+          attr_reader :klass, :defined_fields, :definition
+
+          def type
+            @klass.type
+          end
+
+          def fields
+            @klass.fields
+          end
+
+          def spreads
+            if defined?(@spreads)
+              @spreads
+            else
+              EMPTY_SET
+            end
+          end
+
+          def initialize(klass, defined_fields, definition, spreads)
+            @klass = klass
+            @defined_fields = defined_fields.map do |k, v|
+              [-k.to_s, v]
+            end.to_h
+            @definition = definition
+            @spreads = spreads unless spreads.empty?
+
+            @defined_fields.keys.each do |attr|
+              name = ActiveSupport::Inflector.underscore(attr)
+              @klass::READERS[:"#{name}"] ||= attr
+              @klass::PREDICATES[:"#{name}?"] ||= attr
+            end
+          end
+
+          def new(data = {}, errors = Errors.new)
+            @klass.new(data, errors, self)
           end
         end
 
@@ -46,56 +92,9 @@ module GraphQL
             field_classes[result_name.to_sym] = schema_module.define_class(definition, field_ast_nodes, field_return_type)
           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
+          spreads = definition.indexes[:spreads][ast_nodes.first]
 
-          klass
-        end
-
-        PREDICATE_CACHE = Hash.new { |h, name|
-          h[name] = -> { @data[name] ? true : false }
-        }
-
-        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
-          }
-        }
-
-        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)
-          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])
+          WithDefinition.new(self, field_classes, definition, spreads)
         end
 
         def define_field(name, type)
@@ -132,14 +131,13 @@ module GraphQL
           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 = definition.client.get_type(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
+                                   true
+                                 else
+                                   type_condition = definition.client.get_type(selected_ast_node.type.name)
+                                   applicable_types = definition.client.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|
@@ -150,10 +148,8 @@ module GraphQL
             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 = definition.client.get_type(fragment_definition.type.name)
-            applicable_types = schema.possible_types(type_condition)
+            applicable_types = definition.client.possible_types(type_condition)
             # continue if this object type is one of the types matching the fragment condition
             continue_selection = applicable_types.include?(type)
 
@@ -177,17 +173,16 @@ module GraphQL
       end
 
       class ObjectClass
-        module ClassMethods
-          attr_reader :source_definition
-          attr_reader :_spreads
-        end
-
-        extend ClassMethods
-
-        def initialize(data = {}, errors = Errors.new)
+        def initialize(data = {}, errors = Errors.new, definer = nil)
           @data = data
           @casted_data = {}
           @errors = errors
+
+          # If we are not provided a definition, we can use this empty default
+          definer ||= ObjectType::WithDefinition.new(self.class, {}, nil, [])
+
+          @definer = definer
+          @enforce_collocated_callers = source_definition && source_definition.client.enforce_collocated_callers
         end
 
         # Public: Returns the raw response data
@@ -196,43 +191,87 @@ module GraphQL
         def to_h
           @data
         end
+        alias :to_hash :to_h
 
-        # Public: Return errors associated with data.
-        #
-        # Returns Errors collection.
-        attr_reader :errors
+        def _definer
+          @definer
+        end
 
-        def method_missing(*args)
-          super
-        rescue NoMethodError => e
-          type = self.class.type
+        def _spreads
+          @definer.spreads
+        end
 
-          if ActiveSupport::Inflector.underscore(e.name.to_s) != e.name.to_s
-            raise e
-          end
+        def source_definition
+          @definer.definition
+        end
 
-          all_fields = type.respond_to?(:all_fields) ? type.all_fields : type.fields.values
-          field = all_fields.find do |f|
-            f.name == e.name.to_s || ActiveSupport::Inflector.underscore(f.name) == e.name.to_s
+        def respond_to_missing?(name, priv)
+          if (attr = self.class::READERS[name]) || (attr = self.class::PREDICATES[name])
+            @definer.defined_fields.key?(attr) || super
+          else
+            super
           end
+        end
 
-          unless field
-            raise UnimplementedFieldError, "undefined field `#{e.name}' on #{type.graphql_name} type. https://git.io/v1y3m"
+        # Public: Return errors associated with data.
+        #
+        # It's possible to define "errors" as a field. Ideally this shouldn't
+        # happen, but if it does we should prefer the field rather than the
+        # builtin error type.
+        #
+        # Returns Errors collection.
+        def errors
+          if type = @definer.defined_fields["errors"]
+            read_attribute("errors", type)
+          else
+            @errors
           end
+        end
 
-          if @data.key?(field.name)
-            error_class = ImplicitlyFetchedFieldError
-            message = "implicitly fetched field `#{field.name}' on #{type} type. https://git.io/v1yGL"
+        def method_missing(name, *args)
+          if (attr = self.class::READERS[name]) && (type = @definer.defined_fields[attr])
+            if @enforce_collocated_callers
+              verify_collocated_path do
+                read_attribute(attr, type)
+              end
+            else
+              read_attribute(attr, type)
+            end
+          elsif (attr = self.class::PREDICATES[name]) && @definer.defined_fields[attr]
+            has_attribute?(attr)
           else
-            error_class = UnfetchedFieldError
-            message = "unfetched field `#{field.name}' on #{type} type. https://git.io/v1y3U"
-          end
+            begin
+              super
+            rescue NoMethodError => e
+              type = self.class.type
 
-          raise error_class, message
+              if ActiveSupport::Inflector.underscore(e.name.to_s) != e.name.to_s
+                raise e
+              end
+
+              all_fields = type.respond_to?(:all_fields) ? type.all_fields : type.fields.values
+              field = all_fields.find do |f|
+                f.name == e.name.to_s || ActiveSupport::Inflector.underscore(f.name) == e.name.to_s
+              end
+
+              unless field
+                raise UnimplementedFieldError, "undefined field `#{e.name}' on #{type.graphql_name} type. https://github.com/github-community-projects/graphql-client/blob/master/guides/unimplemented-field-error.md"
+              end
+
+              if @data.key?(field.name)
+                raise ImplicitlyFetchedFieldError, "implicitly fetched field `#{field.name}' on #{type} type. https://github.com/github-community-projects/graphql-client/blob/master/guides/implicitly-fetched-field-error.md"
+              else
+                raise UnfetchedFieldError, "unfetched field `#{field.name}' on #{type} type. https://github.com/github-community-projects/graphql-client/blob/master/guides/unfetched-field-error.md"
+              end
+            end
+          end
         end
 
         def inspect
-          parent = self.class.ancestors.select { |m| m.is_a?(ObjectType) }.last
+          parent = self.class
+          until parent.superclass == ObjectClass
+            parent = parent.superclass
+          end
 
           ivars = @data.map { |key, value|
             if value.is_a?(Hash) || value.is_a?(Array)
@@ -247,6 +286,26 @@ module GraphQL
           buf << ">"
           buf
         end
+
+        private
+
+        def verify_collocated_path
+          location = caller_locations(2, 1)[0]
+
+          CollocatedEnforcement.verify_collocated_path(location, source_definition.source_location[0]) do
+            yield
+          end
+        end
+
+        def read_attribute(attr, type)
+          @casted_data.fetch(attr) do
+            @casted_data[attr] = type.cast(@data[attr], @errors.filter_by_path(attr))
+          end
+        end
+
+        def has_attribute?(attr)
+          !!@data[attr]
+        end
       end
     end
   end

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

@@ -21,7 +21,7 @@ module GraphQL
         end
 
         def define_class(definition, ast_nodes)
-          possible_type_names = definition.client.schema.possible_types(type).map(&:graphql_name)
+          possible_type_names = definition.client.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)
           }

data/lib/graphql/client/schema.rb

@@ -43,7 +43,7 @@ module GraphQL
         def set_class(type_name, klass)
           class_name = normalize_type_name(type_name)
 
-          if constants.include?(class_name.to_sym)
+          if const_defined?(class_name, false)
             raise ArgumentError,
               "Can't define #{class_name} to represent type #{type_name} " \
               "because it's already defined"
@@ -66,9 +66,10 @@ module GraphQL
         end
       end
 
-      def self.generate(schema)
+      def self.generate(schema, raise_on_unknown_enum_value: true)
         mod = Module.new
         mod.extend ClassMethods
+        mod.define_singleton_method(:raise_on_unknown_enum_value) { raise_on_unknown_enum_value }
 
         cache = {}
         schema.types.each do |name, type|

data/lib/graphql/client/type_stack.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+module GraphQL
+  class Client
+    module TypeStack
+      # @return [GraphQL::Schema] the schema whose types are present in this document
+      attr_reader :schema
+
+      # When it enters an object (starting with query or mutation root), it's pushed on this stack.
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::ObjectType, GraphQL::Union, GraphQL::Interface>]
+      attr_reader :object_types
+
+      # When it enters a field, it's pushed on this stack (useful for nested fields, args).
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::Field>] fields which have been entered
+      attr_reader :field_definitions
+
+      # Directives are pushed on, then popped off while traversing the tree
+      # @return [Array<GraphQL::Node::Directive>] directives which have been entered
+      attr_reader :directive_definitions
+
+      # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
+      attr_reader :argument_definitions
+
+      # @return [Array<String>] fields which have been entered (by their AST name)
+      attr_reader :path
+
+      # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
+      # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
+      def initialize(document, schema:, **rest)
+        @schema = schema
+        @object_types = []
+        @field_definitions = []
+        @directive_definitions = []
+        @argument_definitions = []
+        @path = []
+        super(document, **rest)
+      end
+
+      def on_directive(node, parent)
+        directive_defn = @schema.directives[node.name]
+        @directive_definitions.push(directive_defn)
+        super(node, parent)
+      ensure
+        @directive_definitions.pop
+      end
+
+      def on_field(node, parent)
+        parent_type = @object_types.last
+        parent_type = parent_type.unwrap
+
+        field_definition = @schema.get_field(parent_type, node.name)
+        @field_definitions.push(field_definition)
+        if !field_definition.nil?
+          next_object_type = field_definition.type
+          @object_types.push(next_object_type)
+        else
+          @object_types.push(nil)
+        end
+        @path.push(node.alias || node.name)
+        super(node, parent)
+      ensure
+        @field_definitions.pop
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_argument(node, parent)
+        if @argument_definitions.last
+          arg_type = @argument_definitions.last.type.unwrap
+          if arg_type.kind.input_object?
+            argument_defn = arg_type.arguments[node.name]
+          else
+            argument_defn = nil
+          end
+        elsif @directive_definitions.last
+          argument_defn = @directive_definitions.last.arguments[node.name]
+        elsif @field_definitions.last
+          argument_defn = @field_definitions.last.arguments[node.name]
+        else
+          argument_defn = nil
+        end
+        @argument_definitions.push(argument_defn)
+        @path.push(node.name)
+        super(node, parent)
+      ensure
+        @argument_definitions.pop
+        @path.pop
+      end
+
+      def on_operation_definition(node, parent)
+        # eg, QueryType, MutationType
+        object_type = @schema.root_type_for_operation(node.operation_type)
+        @object_types.push(object_type)
+        @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
+        super(node, parent)
+      ensure
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_inline_fragment(node, parent)
+        object_type = if node.type
+                        @schema.get_type(node.type.name)
+                      else
+                        @object_types.last
+                      end
+        if !object_type.nil?
+          object_type = object_type.unwrap
+        end
+        @object_types.push(object_type)
+        @path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
+        super(node, parent)
+      ensure
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_fragment_definition(node, parent)
+        object_type = if node.type
+                        @schema.get_type(node.type.name)
+                      else
+                        @object_types.last
+                      end
+        if !object_type.nil?
+          object_type = object_type.unwrap
+        end
+        @object_types.push(object_type)
+        @path.push("fragment #{node.name}")
+        super(node, parent)
+      ensure
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_fragment_spread(node, parent)
+        @path.push("... #{node.name}")
+        super(node, parent)
+      ensure
+        @path.pop
+      end
+    end
+  end
+end

data/lib/graphql/client/view_module.rb

@@ -133,7 +133,7 @@ module GraphQL
 
         remove_const(name) if placeholder
         const_set(name, mod)
-        mod.unloadable
+        mod.unloadable if mod.respond_to?(:unloadable)
         mod
       end