graphql 0.19.4 → 1.0.0

data/lib/graphql/language/parser.y

@@ -214,7 +214,7 @@ rule
       ELLIPSIS name_without_on directives_list_opt { return make_node(:FragmentSpread, name: val[1], directives: val[2], position_source: val[0]) }
 
   inline_fragment:
-      ELLIPSIS ON name directives_list_opt selection_set {
+      ELLIPSIS ON type directives_list_opt selection_set {
         return make_node(:InlineFragment, {
           type: val[2],
           directives: val[3],
@@ -232,7 +232,7 @@ rule
       }
 
   fragment_definition:
-    FRAGMENT fragment_name_opt ON name_without_on directives_list_opt selection_set {
+    FRAGMENT fragment_name_opt ON type directives_list_opt selection_set {
       return make_node(:FragmentDefinition, {
           name:       val[1],
           type:       val[3],

data/lib/graphql/language/parser_tests.rb

@@ -65,7 +65,7 @@ module GraphQL
                 assert fragment_def.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
                 assert_equal "moreNestedFields", fragment_def.name
                 assert_equal 1, fragment_def.selections.length
-                assert_equal "NestedType", fragment_def.type
+                assert_equal "NestedType", fragment_def.type.name
                 assert_equal 1, fragment_def.directives.length
                 assert_equal [20, 13], fragment_def.position
               end
@@ -173,7 +173,7 @@ module GraphQL
                 let(:typeless_inline_fragment) { query.selections[3] }
 
                 it "gets the type and directives" do
-                  assert_equal "OtherType", inline_fragment.type
+                  assert_equal "OtherType", inline_fragment.type.name
                   assert_equal 2, inline_fragment.selections.length
                   assert_equal 1, inline_fragment.directives.length
                 end

data/lib/graphql/query.rb

@@ -24,12 +24,11 @@ module GraphQL
     # @param query_string [String]
     # @param context [#[]] an arbitrary hash of values which you can access in {GraphQL::Field#resolve}
     # @param variables [Hash] values for `$variables` in the query
-    # @param validate [Boolean] if true, `query_string` will be validated with {StaticValidation::Validator}
     # @param operation_name [String] if the query string contains many operations, this is the one which should be executed
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil)
+    def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil)
       fail ArgumentError, "a query string or document is required" unless query_string || document
 
       @schema = schema
@@ -44,7 +43,6 @@ module GraphQL
       end
       @context = Context.new(query: self, values: context)
       @root_value = root_value
-      @validate = validate
       @operation_name = operation_name
       @fragments = {}
       @operations = {}
@@ -66,6 +64,18 @@ module GraphQL
       @analysis_errors = []
       @internal_representation = nil
       @was_validated = false
+
+      # Trying to execute a document
+      # with no operations returns an empty hash
+      @ast_variables = []
+      if @operations.any?
+        @selected_operation = find_operation(@operations, @operation_name)
+        if @selected_operation.nil?
+          @validation_errors << GraphQL::Query::OperationNameMissingError.new(@operations.keys)
+        else
+          @ast_variables = @selected_operation.variables
+        end
+      end
     end
 
     # Get the result for this query, executing it once
@@ -74,7 +84,7 @@ module GraphQL
         if !valid?
           all_errors = validation_errors + analysis_errors
           if all_errors.any?
-            { "errors" => all_errors }
+            { "errors" => all_errors.map(&:to_h) }
           else
             nil
           end
@@ -93,14 +103,19 @@ module GraphQL
     # Determine the values for variables of this query, using default values
     # if a value isn't provided at runtime.
     #
-    # Raises if a non-null variable isn't provided at runtime.
+    # If some variable is invalid, errors are added to {#validation_errors}.
+    #
     # @return [GraphQL::Query::Variables] Variables to apply to this query
     def variables
-      @variables ||= GraphQL::Query::Variables.new(
-        schema,
-        selected_operation.variables,
-        @provided_variables
-      )
+      @variables ||= begin
+        vars = GraphQL::Query::Variables.new(
+          @schema,
+          @ast_variables,
+          @provided_variables,
+        )
+        @validation_errors.concat(vars.errors)
+        vars
+      end
     end
 
     # @return [Hash<String, nil => GraphQL::InternalRepresentation::Node] Operation name -> Irep node pairs
@@ -136,18 +151,13 @@ module GraphQL
     end
 
     # @return [GraphQL::Language::Nodes::Document, nil]
-    def selected_operation
-      @selected_operation ||= find_operation(@operations, @operation_name)
-    end
+    attr_reader :selected_operation
 
     def valid?
-      if !@was_validated
+      @was_validated ||= begin
         @was_validated = true
-        @valid = if @validate
-          document_valid? && query_possible? && query_valid?
-        else
-          true
-        end
+        @valid = document_valid? && query_valid? && variables.errors.none?
+        true
       end
 
       @valid
@@ -158,23 +168,11 @@ module GraphQL
     # Assert that the passed-in query string is internally consistent
     def document_valid?
       validation_result = schema.static_validator.validate(self)
-      @validation_errors = validation_result[:errors]
+      @validation_errors.concat(validation_result[:errors])
       @internal_representation = validation_result[:irep]
       @validation_errors.none?
     end
 
-    # Given that the document is valid, do we have what we need to
-    # execute the document this time?
-    # - Is there an operation to run?
-    # - Are all variables accounted for?
-    def query_possible?
-      !selected_operation.nil? && variables
-      true
-    rescue GraphQL::Query::OperationNameMissingError, GraphQL::Query::VariableValidationError => err
-      @validation_errors << err.to_h
-      false
-    end
-
     # Given that we _could_ execute this query, _should_ we?
     # - Does it violate any query analyzers?
     def query_valid?
@@ -182,9 +180,8 @@ module GraphQL
         if @query_analyzers.any?
           reduce_results = GraphQL::Analysis.analyze_query(self, @query_analyzers)
           reduce_results
-          .flatten # accept n-dimensional array
-          .select { |r| r.is_a?(GraphQL::AnalysisError) }
-          .map(&:to_h)
+            .flatten # accept n-dimensional array
+            .select { |r| r.is_a?(GraphQL::AnalysisError) }
         else
           []
         end
@@ -195,10 +192,8 @@ module GraphQL
     def find_operation(operations, operation_name)
       if operations.length == 1
         operations.values.first
-      elsif operations.length == 0
+      elsif operations.length == 0 || !operations.key?(operation_name)
         nil
-      elsif !operations.key?(operation_name)
-        raise OperationNameMissingError, operations.keys
       else
         operations[operation_name]
       end

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -61,44 +61,40 @@ module GraphQL
         # is added to the "errors" key.
         def get_raw_value
           middlewares = execution_context.query.schema.middleware
-          field_resolve_step = FieldResolveStep.new(irep_node)
-          resolve_arguments = [parent_type, target, field, arguments, execution_context.query.context]
-          # only run a middleware chain if there are any middleware
-          if middlewares.any?
-            chain = GraphQL::Schema::MiddlewareChain.new(
-              steps: middlewares + [field_resolve_step],
-              arguments: resolve_arguments
-            )
-            chain.call
-          else
-            field_resolve_step.call(*resolve_arguments)
-          end
-        rescue GraphQL::ExecutionError => err
-          err
+          query_context = execution_context.query.context
+          # setup
+          query_context.ast_node = @irep_node.ast_node
+          query_context.irep_node = @irep_node
+
+          resolve_arguments = [parent_type, target, field, arguments, query_context]
+
+          resolve_value = begin
+              # only run a middleware chain if there are any middleware
+              if middlewares.any?
+                chain = GraphQL::Schema::MiddlewareChain.new(
+                  steps: middlewares + [FieldResolveStep],
+                  arguments: resolve_arguments
+                )
+                chain.call
+              else
+                FieldResolveStep.call(*resolve_arguments)
+              end
+            rescue GraphQL::ExecutionError => err
+              err
+            end
+        ensure
+          # teardown
+          query_context.ast_node = nil
+          query_context.irep_node = nil
+          resolve_value
         end
 
 
         # A `.call`-able suitable to be the last step in a middleware chain
-        class FieldResolveStep
-          def initialize(irep_node)
-            @irep_node = irep_node
-          end
-
+        module FieldResolveStep
           # Execute the field's resolve method
-          def call(_parent_type, parent_object, field_definition, field_args, context, _next = nil)
-            # setup
-            context.ast_node = @irep_node.ast_node
-            context.irep_node = @irep_node
-
-            # resolve
-            value = field_definition.resolve(parent_object, field_args, context)
-
-            # teardown
-            context.ast_node = nil
-            context.irep_node = nil
-
-            # return
-            value
+          def self.call(_parent_type, parent_object, field_definition, field_args, context, _next = nil)
+            field_definition.resolve(parent_object, field_args, context)
           end
         end
       end

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -19,8 +19,11 @@ module GraphQL
           end
 
           def result
-            return nil if value.nil? || value.is_a?(GraphQL::ExecutionError)
-            non_null_result
+            if value.nil? || value.is_a?(GraphQL::ExecutionError)
+              nil
+            else
+              non_null_result
+            end
           end
 
           def non_null_result

data/lib/graphql/query/variables.rb

@@ -2,9 +2,13 @@ module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.
     class Variables
+      # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
+      attr_reader :errors
+
       def initialize(schema, ast_variables, provided_variables)
         @schema = schema
         @provided_variables = provided_variables
+        @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           variable_name = ast_variable.name
           memo[variable_name] = get_graphql_value(ast_variable)
@@ -29,7 +33,7 @@ module GraphQL
 
         validation_result = variable_type.validate_input(provided_value)
         if !validation_result.valid?
-          raise GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
+          @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
         elsif provided_value.nil?
           GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
         else

data/lib/graphql/relay/base_connection.rb

@@ -11,8 +11,6 @@ module GraphQL
     #   - {#max_page_size} (the specified maximum page size that can be returned from a connection)
     #
     class BaseConnection
-      extend Gem::Deprecate
-
       # Just to encode data in the cursor, use something that won't conflict
       CURSOR_SEPARATOR = "---"
 
@@ -21,8 +19,6 @@ module GraphQL
       CONNECTION_IMPLEMENTATIONS = {}
 
       class << self
-        extend Gem::Deprecate
-
         # Find a connection implementation suitable for exposing `nodes`
         #
         # @param [Object] A collection of nodes (eg, Array, AR::Relation)
@@ -30,13 +26,14 @@ module GraphQL
         def connection_for_nodes(nodes)
           # Check for class _names_ because classes can be redefined in Rails development
           ancestor_names = nodes.class.ancestors.map(&:name)
-          implementation = CONNECTION_IMPLEMENTATIONS.find do |nodes_class_name, connection_class|
-            ancestor_names.include? nodes_class_name
+          implementation_class_name = ancestor_names.find do |ancestor_class_name|
+            CONNECTION_IMPLEMENTATIONS.include? ancestor_class_name
           end
-          if implementation.nil?
+
+          if implementation_class_name.nil?
             raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
           else
-            implementation[1]
+            CONNECTION_IMPLEMENTATIONS[implementation_class_name]
           end
         end
 
@@ -47,10 +44,6 @@ module GraphQL
         def register_connection_implementation(nodes_class, connection_class)
           CONNECTION_IMPLEMENTATIONS[nodes_class.name] = connection_class
         end
-
-        # @deprecated use {#connection_for_nodes} instead
-        alias :connection_for_items :connection_for_nodes
-        deprecate(:connection_for_items, :connection_for_nodes, 2016, 9)
       end
 
       attr_reader :nodes, :arguments, :max_page_size, :parent, :field
@@ -69,10 +62,6 @@ module GraphQL
         @parent = parent
       end
 
-      # @deprecated use {#nodes} instead
-      alias :object :nodes
-      deprecate(:object, :nodes, 2016, 9)
-
       # Provide easy access to provided arguments:
       METHODS_FROM_ARGUMENTS = [:first, :after, :last, :before]
 

data/lib/graphql/relay/mutation.rb

@@ -76,13 +76,6 @@ module GraphQL
 
       def resolve=(new_resolve_proc)
         ensure_defined
-
-        resolve_arity = get_arity(new_resolve_proc)
-        if resolve_arity == 2
-          warn("Mutation#resolve functions should be defined with three arguments: (root_obj, input, context). Two-argument mutation resolves are deprecated.")
-          new_resolve_proc = DeprecatedMutationResolve.new(new_resolve_proc)
-        end
-
         @resolve_proc = MutationResolve.new(self, new_resolve_proc, wrap_result: has_generated_return_type?)
       end
 
@@ -176,16 +169,6 @@ module GraphQL
         end
       end
 
-      class DeprecatedMutationResolve
-        def initialize(two_argument_resolve)
-          @two_argument_resolve = two_argument_resolve
-        end
-
-        def call(obj, args, ctx)
-          @two_argument_resolve.call(args[:input], ctx)
-        end
-      end
-
       class MutationResolve
         def initialize(mutation, resolve, wrap_result:)
           @mutation = mutation

data/lib/graphql/schema.rb

@@ -74,16 +74,8 @@ module GraphQL
     # @param subscription [GraphQL::ObjectType] the subscription root for the schema
     # @param max_depth [Integer] maximum query nesting (if it's greater, raise an error)
     # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
-    def initialize(query: nil, mutation: nil, subscription: nil, max_depth: nil, max_complexity: nil, types: [])
-      if query
-        warn("Schema.new is deprecated, use Schema.define instead")
-      end
-      @query    = query
-      @mutation = mutation
-      @subscription = subscription
-      @max_depth = max_depth
-      @max_complexity = max_complexity
-      @orphan_types = types
+    def initialize
+      @orphan_types = []
       @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
       @middleware = []

data/lib/graphql/schema/loader.rb

@@ -58,7 +58,7 @@ module GraphQL
               name: type["name"],
               description: type["description"],
               values: type["enumValues"].map { |enum|
-                EnumType::EnumValue.new(
+                EnumType::EnumValue.define(
                   name: enum["name"],
                   description: enum["description"],
                   deprecation_reason: enum["deprecationReason"],

data/lib/graphql/schema/printer.rb

@@ -116,7 +116,7 @@ module GraphQL
               "#{print_description(arg, "  #{indentation}", i == 0)}  #{indentation}"\
               "#{print_input_value(arg)}"
             }.join("\n")
-            out << "\n)"
+            out << "\n#{indentation})"
           end
 
           def print_input_value(arg)

data/lib/graphql/static_validation/rules/fragment_spreads_are_possible.rb

@@ -22,7 +22,7 @@ module GraphQL
 
         context.visitor[GraphQL::Language::Nodes::Document].leave << ->(doc_node, parent) {
           spreads_to_validate.each do |frag_spread|
-            fragment_child_name = context.fragments[frag_spread.node.name].type
+            fragment_child_name = context.fragments[frag_spread.node.name].type.name
             fragment_child = context.schema.types.fetch(fragment_child_name, nil) # Might be non-existent type name
             if fragment_child
               validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)

data/lib/graphql/static_validation/rules/fragment_types_exist.rb

@@ -18,9 +18,10 @@ module GraphQL
 
       def validate_type_exists(node, context)
         return unless node.type
-        type = context.schema.types.fetch(node.type, nil)
+        type_name = node.type.name
+        type = context.schema.types.fetch(type_name, nil)
         if type.nil?
-          context.errors << message("No such type #{node.type}, so it can't be a fragment condition", node, context: context)
+          context.errors << message("No such type #{type_name}, so it can't be a fragment condition", node, context: context)
           GraphQL::Language::Visitor::SKIP
         end
       end

data/lib/graphql/static_validation/rules/fragments_are_on_composite_types.rb

@@ -19,12 +19,16 @@ module GraphQL
       private
 
       def validate_type_is_composite(node, context)
-        type_name = node.type
-        return unless type_name
-        type_def = context.schema.types[type_name]
-        if type_def.nil? || !type_def.kind.composite?
-          context.errors <<  message("Invalid fragment on type #{type_name} (must be Union, Interface or Object)", node, context: context)
-          GraphQL::Language::Visitor::SKIP
+        node_type = node.type
+        if node_type.nil?
+          # Inline fragment on the same type
+        else
+          type_name = node_type.to_query_string
+          type_def = context.schema.types.fetch(type_name, nil)
+          if type_def.nil? || !type_def.kind.composite?
+            context.errors <<  message("Invalid fragment on type #{type_name} (must be Union, Interface or Object)", node, context: context)
+            GraphQL::Language::Visitor::SKIP
+          end
         end
       end
     end