graphql 1.2.6 → 1.3.0

data/lib/graphql/compatibility/execution_specification/counter_schema.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module GraphQL
+  module Compatibility
+    module ExecutionSpecification
+      module CounterSchema
+        def self.build(execution_strategy)
+          counter_type = nil
+          schema = nil
+
+          has_count_interface = GraphQL::InterfaceType.define do
+            name "HasCount"
+            field :count, types.Int
+            field :counter, ->{ counter_type }
+          end
+
+          counter_type = GraphQL::ObjectType.define do
+            name "Counter"
+            interfaces [has_count_interface]
+            field :count, types.Int, resolve: ->(o,a,c) { schema.metadata[:count] += 1 }
+            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+          end
+
+          alt_counter_type = GraphQL::ObjectType.define do
+            name "AltCounter"
+            interfaces [has_count_interface]
+            field :count, types.Int, resolve: ->(o,a,c) { schema.metadata[:count] += 1 }
+            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+          end
+
+          has_counter_interface = GraphQL::InterfaceType.define do
+            name "HasCounter"
+            field :counter, counter_type
+          end
+
+          query_type = GraphQL::ObjectType.define do
+            name "Query"
+            interfaces [has_counter_interface]
+            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+          end
+
+          schema = GraphQL::Schema.define(
+            query: query_type,
+            resolve_type: ->(o, c) { o == :counter ? counter_type : nil },
+            orphan_types: [alt_counter_type],
+            query_execution_strategy: execution_strategy,
+          )
+          schema.metadata[:count] = 0
+          schema
+        end
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+module GraphQL
+  module Compatibility
+    module ExecutionSpecification
+      module SpecificationSchema
+        BOGUS_NODE = OpenStruct.new({ bogus: true })
+
+        DATA = {
+          "1001" => OpenStruct.new({
+            name: "Fannie Lou Hamer",
+            birthdate: Time.new(1917, 10, 6),
+            organization_ids: [],
+          }),
+          "1002" => OpenStruct.new({
+            name: "John Lewis",
+            birthdate: Time.new(1940, 2, 21),
+            organization_ids: ["2001"],
+          }),
+          "1003" => OpenStruct.new({
+            name: "Diane Nash",
+            birthdate: Time.new(1938, 5, 15),
+            organization_ids: ["2001", "2002"],
+          }),
+          "1004" => OpenStruct.new({
+            name: "Ralph Abernathy",
+            birthdate: Time.new(1926, 3, 11),
+            organization_ids: ["2002"],
+          }),
+          "2001" => OpenStruct.new({
+            name: "SNCC",
+            leader_id: nil, # fail on purpose
+          }),
+          "2002" => OpenStruct.new({
+            name: "SCLC",
+            leader_id: "1004",
+          }),
+          "2003" => BOGUS_NODE,
+        }
+
+        # A list object must implement #each
+        class CustomCollection
+          def initialize(storage)
+            @storage = storage
+          end
+
+          def each
+            @storage.each { |i| yield(i) }
+          end
+        end
+
+        module TestMiddleware
+          def self.call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
+            query_context[:middleware_log] && query_context[:middleware_log] << field_definition.name
+            next_middleware.call
+          end
+        end
+
+        def self.build(execution_strategy)
+          organization_type = nil
+
+          timestamp_type = GraphQL::ScalarType.define do
+            name "Timestamp"
+            coerce_input ->(value) { Time.at(value.to_i) }
+            coerce_result ->(value) { value.to_i }
+          end
+
+          named_entity_interface_type = GraphQL::InterfaceType.define do
+            name "NamedEntity"
+            field :name, !types.String
+          end
+
+          person_type = GraphQL::ObjectType.define do
+            name "Person"
+            interfaces [named_entity_interface_type]
+            field :name, !types.String
+            field :birthdate, timestamp_type
+            field :age, types.Int do
+              argument :on, !timestamp_type
+              resolve ->(obj, args, ctx) {
+                if obj.birthdate.nil?
+                  nil
+                else
+                  age_on = args[:on]
+                  age_years = age_on.year - obj.birthdate.year
+                  this_year_birthday = Time.new(age_on.year, obj.birthdate.month, obj.birthdate.day)
+                  if this_year_birthday > age_on
+                    age_years -= 1
+                  end
+                end
+                age_years
+              }
+            end
+            field :organizations, types[organization_type] do
+              resolve ->(obj, args, ctx) {
+                CustomCollection.new(obj.organization_ids.map { |id| DATA[id] })
+              }
+            end
+            field :first_organization, !organization_type do
+              resolve ->(obj, args, ctx) {
+                DATA[obj.organization_ids.first]
+              }
+            end
+          end
+
+          organization_type = GraphQL::ObjectType.define do
+            name "Organization"
+            interfaces [named_entity_interface_type]
+            field :name, !types.String
+            field :leader, !person_type do
+              resolve ->(obj, args, ctx) {
+                DATA[obj.leader_id] || (ctx[:return_error] ? ExecutionError.new("Error on Nullable") : nil)
+              }
+            end
+            field :returnedError, types.String do
+              resolve ->(o, a, c) {
+                GraphQL::ExecutionError.new("This error was returned")
+              }
+            end
+            field :raisedError, types.String do
+              resolve ->(o, a, c) {
+                raise GraphQL::ExecutionError.new("This error was raised")
+              }
+            end
+
+            field :nodePresence, !types[!types.Boolean] do
+              resolve ->(o, a, ctx) {
+                [
+                  ctx.irep_node.is_a?(GraphQL::InternalRepresentation::Node),
+                  ctx.ast_node.is_a?(GraphQL::Language::Nodes::AbstractNode),
+                  false, # just testing
+                ]
+              }
+            end
+          end
+
+          node_union_type = GraphQL::UnionType.define do
+            name "Node"
+            possible_types [person_type, organization_type]
+          end
+
+          query_type = GraphQL::ObjectType.define do
+            name "Query"
+            field :node, node_union_type do
+              argument :id, !types.ID
+              resolve ->(obj, args, ctx) {
+                obj[args[:id]]
+              }
+            end
+
+            field :requiredNode, node_union_type.to_non_null_type do
+              argument :id, !types.ID
+              resolve ->(obj, args, ctx) {
+                obj[args[:id]]
+              }
+            end
+
+            field :organization, !organization_type do
+              argument :id, !types.ID
+              resolve ->(obj, args, ctx) {
+                args[:id].start_with?("2") && obj[args[:id]]
+              }
+            end
+
+            field :organizations, types[organization_type] do
+              resolve ->(obj, args, ctx) {
+                [obj["2001"], obj["2002"]]
+              }
+            end
+          end
+
+          GraphQL::Schema.define do
+            query_execution_strategy execution_strategy
+            query query_type
+
+            resolve_type ->(obj, ctx) {
+              if obj.respond_to?(:birthdate)
+                person_type
+              elsif obj.respond_to?(:leader_id)
+                organization_type
+              else
+                nil
+              end
+            }
+
+            type_error ->(err, ctx) {
+              ctx[:type_errors] && (ctx[:type_errors] << err.value)
+              ctx[:gobble] || GraphQL::Schema::DefaultTypeError.call(err, ctx)
+            }
+            middleware(TestMiddleware)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+require "graphql/compatibility/lazy_execution_specification/lazy_schema"
+
+module GraphQL
+  module Compatibility
+    module LazyExecutionSpecification
+      # @param execution_strategy [<#new, #execute>] An execution strategy class
+      # @return [Class<Minitest::Test>] A test suite for this execution strategy
+      def self.build_suite(execution_strategy)
+        Class.new(Minitest::Test) do
+          class << self
+            attr_accessor :lazy_schema
+          end
+
+          self.lazy_schema = LazySchema.build(execution_strategy)
+
+          def test_it_resolves_lazy_values
+            pushes = []
+            query_str = %|
+            {
+              p1: push(value: 1) {
+                value
+              }
+              p2: push(value: 2) {
+                push(value: 3) {
+                  value
+                }
+              }
+              p3: push(value: 4) {
+                push(value: 5) {
+                  value
+                }
+              }
+            }
+            |
+            res = self.class.lazy_schema.execute(query_str, context: {pushes: pushes})
+
+            expected_data = {
+              "p1"=>{"value"=>1},
+              "p2"=>{"push"=>{"value"=>3}},
+              "p3"=>{"push"=>{"value"=>5}},
+            }
+            assert_equal expected_data, res["data"]
+
+            expected_pushes = [
+              [1,2,4], # first level
+              [3,5], # second level
+            ]
+            assert_equal expected_pushes, pushes
+          end
+
+          def test_it_maintains_path
+            query_str = %|
+            {
+              push(value: 2) {
+                push(value: 3) {
+                  fail1: push(value: 14) {
+                    value
+                  }
+                  fail2: push(value: 14) {
+                    value
+                  }
+                }
+              }
+            }
+            |
+            res = self.class.lazy_schema.execute(query_str, context: {pushes: []})
+            assert_equal nil, res["data"]
+            assert_equal 2, res["errors"].length
+            assert_equal ["push", "push", "fail1", "value"], res["errors"][0]["path"]
+            assert_equal ["push", "push", "fail2", "value"], res["errors"][1]["path"]
+          end
+
+          def test_it_resolves_mutation_values_eagerly
+            pushes = []
+            query_str = %|
+            mutation {
+              p1: push(value: 1) {
+                value
+              }
+              p2: push(value: 2) {
+                push(value: 3) {
+                  value
+                }
+              }
+              p3: push(value: 4) {
+                p5: push(value: 5) {
+                  value
+                }
+                p6: push(value: 6) {
+                  value
+                }
+              }
+            }
+            |
+            res = self.class.lazy_schema.execute(query_str, context: {pushes: pushes})
+
+            expected_data = {
+              "p1"=>{"value"=>1},
+              "p2"=>{"push"=>{"value"=>3}},
+              "p3"=>{"p5"=>{"value"=>5},"p6"=>{"value"=>6}},
+            }
+            assert_equal expected_data, res["data"]
+
+            expected_pushes = [
+              [1],        # first operation
+              [2], [3],   # second operation
+              [4], [5, 6], # third operation
+            ]
+            assert_equal expected_pushes, pushes
+          end
+
+          def test_it_resolves_lazy_connections
+            pushes = []
+            query_str = %|
+            {
+              pushes(values: [1,2,3]) {
+                edges {
+                  node {
+                    value
+                    push(value: 4) {
+                      value
+                    }
+                  }
+                }
+              }
+            }
+            |
+            res = self.class.lazy_schema.execute(query_str, context: {pushes: pushes})
+
+            expected_edges = [
+              {"node"=>{"value"=>1, "push"=>{"value"=>4}}},
+              {"node"=>{"value"=>2, "push"=>{"value"=>4}}},
+              {"node"=>{"value"=>3, "push"=>{"value"=>4}}},
+            ]
+            assert_equal expected_edges, res["data"]["pushes"]["edges"]
+            assert_equal [[1, 2, 3], [4, 4, 4]], pushes
+          end
+
+          def test_it_calls_lazy_resolve_instrumentation
+            query_str = %|
+            {
+              p1: push(value: 1) {
+                value
+              }
+              p2: push(value: 2) {
+                push(value: 3) {
+                  value
+                }
+              }
+              pushes(values: [1,2,3]) {
+                edges {
+                  node {
+                    value
+                    push(value: 4) {
+                      value
+                    }
+                  }
+                }
+              }
+            }
+            |
+
+            log = []
+            res = self.class.lazy_schema.execute(query_str, context: {lazy_instrumentation: log, pushes: []})
+            expected_log = [
+              "PUSH",
+              "Query.push: 1",
+              "Query.push: 2",
+              "PUSH",
+              "LazyPush.push: 3",
+              "LazyPushEdge.node: 1",
+              "LazyPushEdge.node: 2",
+              "LazyPushEdge.node: 3",
+              "PUSH",
+              "LazyPush.push: 4",
+              "LazyPush.push: 4",
+              "LazyPush.push: 4",
+            ]
+            assert_equal expected_log, log
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/compatibility/lazy_execution_specification/lazy_schema.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module GraphQL
+  module Compatibility
+    module LazyExecutionSpecification
+      module LazySchema
+        class LazyPush
+          attr_reader :value
+          def initialize(ctx, value)
+            if value == 13
+              @value = nil
+            elsif value == 14
+              @value = GraphQL::ExecutionError.new("oops!")
+            else
+              @value = value
+            end
+            @context = ctx
+            pushes = @context[:lazy_pushes] ||= []
+            pushes << @value
+          end
+
+          def push
+            if @context[:lazy_pushes].include?(@value)
+              @context[:lazy_instrumentation] && @context[:lazy_instrumentation] << "PUSH"
+              @context[:pushes] << @context[:lazy_pushes]
+              @context[:lazy_pushes] = []
+            end
+            self
+          end
+        end
+
+        class LazyPushCollection
+          def initialize(ctx, values)
+            @ctx = ctx
+            @values = values
+          end
+
+          def push
+            @values.map { |v| LazyPush.new(@ctx, v) }
+          end
+        end
+
+        module LazyInstrumentation
+          def self.instrument(type, field)
+            prev_lazy_resolve = field.lazy_resolve_proc
+            field.redefine {
+              lazy_resolve ->(o, a, c) {
+                result = prev_lazy_resolve.call(o, a, c)
+                c[:lazy_instrumentation] && c[:lazy_instrumentation].push("#{type.name}.#{field.name}: #{o.value}")
+                result
+              }
+            }
+          end
+        end
+
+        def self.build(execution_strategy)
+          lazy_push_type = GraphQL::ObjectType.define do
+            name "LazyPush"
+            field :value, !types.Int
+            field :push, !lazy_push_type do
+              argument :value, types.Int
+              resolve ->(o, a, c) {
+                LazyPush.new(c, a[:value])
+              }
+            end
+          end
+
+          query_type = GraphQL::ObjectType.define do
+            name "Query"
+            field :push, !lazy_push_type do
+              argument :value, types.Int
+              resolve ->(o, a, c) {
+                LazyPush.new(c, a[:value])
+              }
+            end
+
+            connection :pushes, lazy_push_type.connection_type do
+              argument :values, types[types.Int]
+              resolve ->(o, a, c) {
+                LazyPushCollection.new(c, a[:values])
+              }
+            end
+          end
+
+          GraphQL::Schema.define do
+            query(query_type)
+            mutation(query_type)
+            query_execution_strategy(execution_strategy)
+            mutation_execution_strategy(execution_strategy)
+            lazy_resolve(LazyPush, :push)
+            lazy_resolve(LazyPushCollection, :push)
+            instrument(:field, LazyInstrumentation)
+          end
+        end
+      end
+    end
+  end
+end