graphql 1.2.6 → 1.3.0

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "graphql/compatibility/query_parser_specification/query_assertions"
 require "graphql/compatibility/query_parser_specification/parse_error_specification"
 

data/lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Compatibility
     module QueryParserSpecification

data/lib/graphql/compatibility/query_parser_specification/query_assertions.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Compatibility
     module QueryParserSpecification

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Compatibility
     # This asserts that a given parse function turns a string into

data/lib/graphql/define.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "graphql/define/assign_argument"
 require "graphql/define/assign_connection"
 require "graphql/define/assign_enum_value"

data/lib/graphql/define/assign_argument.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     # Turn argument configs into a {GraphQL::Argument}.

data/lib/graphql/define/assign_connection.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     module AssignConnection

data/lib/graphql/define/assign_enum_value.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     # Turn enum value configs into a {GraphQL::EnumType::EnumValue} and register it with the {GraphQL::EnumType}

data/lib/graphql/define/assign_global_id_field.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     module AssignGlobalIdField

data/lib/graphql/define/assign_object_field.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     # Turn field configs into a {GraphQL::Field} and attach it to a {GraphQL::ObjectType} or {GraphQL::InterfaceType}

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     class DefinedObjectProxy

data/lib/graphql/define/instance_definable.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     # This module provides the `.define { ... }` API for
@@ -94,15 +95,19 @@ module GraphQL
         nil
       end
 
-      # Make a new instance of this class, then
-      # re-run any definitions on that object.
+      # Shallow-copy this object, then apply new definitions to the copy.
+      # @see {#define} for arguments
       # @return [InstanceDefinable] A new instance, with any extended definitions
       def redefine(**kwargs, &block)
         ensure_defined
-        new_instance = self.class.new
-        applied_definitions.each { |defn| new_instance.define(defn.define_keywords, &defn.define_proc) }
-        new_instance.define(**kwargs, &block)
-        new_instance
+        new_inst = self.dup
+        new_inst.define(**kwargs, &block)
+        new_inst
+      end
+
+      def initialize_copy(other)
+        super
+        @metadata = other.metadata.dup
       end
 
       private
@@ -125,16 +130,10 @@ module GraphQL
           if defn.define_proc
             defn_proxy.instance_eval(&defn.define_proc)
           end
-
-          applied_definitions << defn
         end
         nil
       end
 
-      def applied_definitions
-        @applied_definitions ||= []
-      end
-
       class Definition
         attr_reader :define_keywords, :define_proc
         def initialize(define_keywords, define_proc)

data/lib/graphql/define/non_null_with_bang.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     # Wrap the object in NonNullType in response to `!`

data/lib/graphql/define/type_definer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Define
     # Some conveniences for definining return & argument types.

data/lib/graphql/directive.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # Directives are server-defined hooks for modifying execution.
   #

data/lib/graphql/directive/deprecated_directive.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 GraphQL::Directive::DeprecatedDirective = GraphQL::Directive.define do
   name "deprecated"
   description "Marks an element of a GraphQL schema as no longer supported."

data/lib/graphql/directive/include_directive.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 GraphQL::Directive::IncludeDirective = GraphQL::Directive.define do
   name "include"
   description "Directs the executor to include this field or fragment only when the `if` argument is true."

data/lib/graphql/directive/skip_directive.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 GraphQL::Directive::SkipDirective = GraphQL::Directive.define do
   name "skip"
   description "Directs the executor to skip this field or fragment when the `if` argument is true."

data/lib/graphql/enum_type.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   # Represents a collection of related values.
   # By convention, enum names are `SCREAMING_CASE_NAMES`,
@@ -78,6 +79,12 @@ module GraphQL
       @values_by_name = {}
     end
 
+    def initialize_copy(other)
+      super
+      self.values = other.values.values
+    end
+
+
     # @param new_values [Array<EnumValue>] The set of values contained in this type
     def values=(new_values)
       @values_by_name = {}
@@ -104,7 +111,7 @@ module GraphQL
       matching_value = allowed_values.find { |v| v.name == value_name }
 
       if matching_value.nil?
-        result.add_problem("Expected #{JSON.generate(value_name, quirks_mode: true)} to be one of: #{allowed_values.map(&:name).join(', ')}")
+        result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:name).join(', ')}")
       end
 
       result

data/lib/graphql/execution.rb

@@ -1,2 +1,7 @@
+# frozen_string_literal: true
 require "graphql/execution/directive_checks"
+require "graphql/execution/execute"
+require "graphql/execution/field_result"
+require "graphql/execution/lazy"
+require "graphql/execution/selection_result"
 require "graphql/execution/typecast"

data/lib/graphql/execution/directive_checks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   module Execution
     # Boolean checks for how an AST node's directives should

data/lib/graphql/execution/execute.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # A valid execution strategy
+    class Execute
+      PROPAGATE_NULL = :__graphql_propagate_null__
+
+      def execute(ast_operation, root_type, query)
+        result = resolve_selection(
+          query.root_value,
+          root_type,
+          query.irep_selection,
+          query.context,
+          mutation: query.mutation?
+        )
+
+        GraphQL::Execution::Lazy.resolve(result)
+
+        result.to_h
+      end
+
+      private
+
+      def resolve_selection(object, current_type, selection, query_ctx, mutation: false )
+        query = query_ctx.query
+
+        selection_result = SelectionResult.new
+
+        selection.each_selection(type: current_type) do |name, subselection|
+          field = query.get_field(current_type, subselection.definition_name)
+          field_result = resolve_field(
+            selection_result,
+            subselection,
+            current_type,
+            field,
+            object,
+            query_ctx
+          )
+
+          if mutation
+            GraphQL::Execution::Lazy.resolve(field_result)
+          end
+
+          selection_result.set(name, field_result)
+        end
+
+        selection_result
+      end
+
+      def resolve_field(owner, selection, parent_type, field, object, query_ctx)
+        query = query_ctx.query
+        field_ctx = query_ctx.spawn(
+          parent_type: parent_type,
+          field: field,
+          key: selection.name,
+          selection: selection,
+        )
+
+        arguments = query.arguments_for(selection.irep_node, field)
+        middlewares = query.schema.middleware
+        resolve_arguments = [parent_type, object, field, arguments, field_ctx]
+
+        raw_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
+
+        result = if query.schema.lazy?(raw_value)
+          field.prepare_lazy(raw_value, arguments, field_ctx).then { |inner_value|
+            continue_resolve_field(selection, parent_type, field, inner_value, field_ctx)
+          }
+        elsif raw_value.is_a?(GraphQL::Execution::Lazy)
+          # It came from a connection resolve, assume it was already instrumented
+          raw_value.then { |inner_value|
+            continue_resolve_field(selection, parent_type, field, inner_value, field_ctx)
+          }
+        else
+          continue_resolve_field(selection, parent_type, field, raw_value, field_ctx)
+        end
+
+        FieldResult.new(
+          owner: owner,
+          field: field,
+          value: result,
+        )
+      end
+
+      def continue_resolve_field(selection, parent_type, field, raw_value, field_ctx)
+        query = field_ctx.query
+
+        case raw_value
+        when GraphQL::ExecutionError
+          raw_value.ast_node = field_ctx.ast_node
+          raw_value.path = field_ctx.path
+          query.context.errors.push(raw_value)
+        when Array
+          list_errors = raw_value.each_with_index.select { |value, _| value.is_a?(GraphQL::ExecutionError) }
+          if list_errors.any?
+            list_errors.each do |error, index|
+              error.ast_node = field_ctx.ast_node
+              error.path = field_ctx.path + [index]
+              query.context.errors.push(error)
+            end
+          end
+        end
+
+        resolve_value(
+          parent_type,
+          field,
+          field.type,
+          raw_value,
+          selection,
+          field_ctx,
+        )
+      end
+
+      def resolve_value(parent_type, field_defn, field_type, value, selection, field_ctx)
+        if value.nil?
+          if field_type.kind.non_null?
+            type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
+            field_ctx.schema.type_error(type_error, field_ctx)
+            PROPAGATE_NULL
+          else
+            nil
+          end
+        elsif value.is_a?(GraphQL::ExecutionError)
+          if field_type.kind.non_null?
+            PROPAGATE_NULL
+          else
+            nil
+          end
+        else
+          case field_type.kind
+          when GraphQL::TypeKinds::SCALAR
+            field_type.coerce_result(value)
+          when GraphQL::TypeKinds::ENUM
+            field_type.coerce_result(value, field_ctx.query.warden)
+          when GraphQL::TypeKinds::LIST
+            wrapped_type = field_type.of_type
+            i = 0
+            result = []
+            value.each do |inner_value|
+              inner_ctx = field_ctx.spawn(
+                key: i,
+                selection: selection,
+                parent_type: parent_type,
+                field: field_defn,
+              )
+
+              result << resolve_value(
+                parent_type,
+                field_defn,
+                wrapped_type,
+                inner_value,
+                selection,
+                inner_ctx,
+              )
+              i += 1
+            end
+            result
+          when GraphQL::TypeKinds::NON_NULL
+            wrapped_type = field_type.of_type
+            inner_value = resolve_value(
+              parent_type,
+              field_defn,
+              wrapped_type,
+              value,
+              selection,
+              field_ctx,
+            )
+          when GraphQL::TypeKinds::OBJECT
+            resolve_selection(
+              value,
+              field_type,
+              selection,
+              field_ctx
+            )
+          when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
+            query = field_ctx.query
+            resolved_type = query.resolve_type(value)
+            possible_types = query.possible_types(field_type)
+
+            if !possible_types.include?(resolved_type)
+              type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+              field_ctx.schema.type_error(type_error, field_ctx)
+              PROPAGATE_NULL
+            else
+              resolve_value(
+                parent_type,
+                field_defn,
+                resolved_type,
+                value,
+                selection,
+                field_ctx,
+              )
+            end
+          else
+            raise("Unknown type kind: #{field_type.kind}")
+          end
+        end
+      end
+
+      # A `.call`-able suitable to be the last step in a middleware chain
+      module FieldResolveStep
+        # Execute the field's resolve method
+        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
+  end
+end

data/lib/graphql/execution/field_result.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    # This is one key-value pair in a GraphQL response.
+    class FieldResult
+      # @return [Any, Lazy] the GraphQL-ready response value, or a {Lazy} instance
+      attr_reader :value
+
+      # @return [GraphQL::Field] The field which resolved this value
+      attr_reader :field
+
+      # @return [SelectionResult] The result object that this field belongs to
+      attr_reader :owner
+
+      def initialize(field:, value:, owner:)
+        @field = field
+        @owner = owner
+        self.value = value
+      end
+
+      # Set a new value for this field in the response.
+      # It may be updated after resolving a {Lazy}.
+      # If it is {Execute::PROPAGATE_NULL}, tell the owner to propagate null.
+      # If the value is a {SelectionResult}, make a link with it, and if it's already null,
+      # propagate the null as needed.
+      # @param new_value [Any] The GraphQL-ready value
+      def value=(new_value)
+        if new_value.is_a?(SelectionResult)
+          if new_value.invalid_null?
+            new_value = GraphQL::Execution::Execute::PROPAGATE_NULL
+          else
+            new_value.owner = self
+          end
+        end
+
+        if new_value == GraphQL::Execution::Execute::PROPAGATE_NULL
+          if field.type.kind.non_null?
+            @owner.propagate_null
+          else
+            @value = nil
+          end
+        else
+          @value = new_value
+        end
+      end
+
+      def inspect
+        "#<FieldResult #{value.inspect} (#{field.type})>"
+      end
+    end
+  end
+end