graphql 1.7.6 → 1.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ee2881b8335c9299d2dd2b707810856bb34d956
-  data.tar.gz: d23544e543addd64583dbcf82280fc92454a515c
+  metadata.gz: 38483eef219e223ada69c9b3abf6be4b21b18631
+  data.tar.gz: 6e7b06898fbc81c29dd817ee9817ae54e4a44ada
 SHA512:
-  metadata.gz: db14299e06ef27b4f177980705c4f70d6b1d2a6defef6efad0a0b15db493ee1501c820c6fd298a60bc5ffdaf817d50abe4e7c2c145278da5e1ac46866e0a3648
-  data.tar.gz: 4776fe2f611c0cb93778fbf6101dfb81a3f08244bce650dccfbc2c999886ac0aac3d26f06533c6722c2e6aceab371ef9aa419f8d9b192301f2674519d5f66848
+  metadata.gz: 8c1813ee4f6758846e9f5620d1952517c9d7a3d714e265d18da05fcd68425f152afdae56f8c400fd55d4e455e03443f26d90e04fd69578d85c71b3130f5eaf0f
+  data.tar.gz: 41480a626d5acf9db70ea864438e192bab03ec56ad89c137f9f5e63e9ada426c3fd812b9099e8f4c621e3705740fd7daf1d1f74019c632ebd19f54e62608eb90

data/lib/generators/graphql/function_generator.rb

@@ -11,7 +11,7 @@ module Graphql
       source_root File.expand_path('../templates', __FILE__)
 
       def create_function_file
-        template "function.erb", "#{options[:directory]}/functions/#{file_name}.rb"
+        template "function.erb", "#{options[:directory]}/functions/#{file_path}.rb"
       end
     end
   end

data/lib/generators/graphql/loader_generator.rb

@@ -13,7 +13,7 @@ module Graphql
       source_root File.expand_path('../templates', __FILE__)
 
       def create_loader_file
-        template "loader.erb", "#{options[:directory]}/loaders/#{file_name}.rb"
+        template "loader.erb", "#{options[:directory]}/loaders/#{file_path}.rb"
       end
     end
   end

data/lib/generators/graphql/mutation_generator.rb

@@ -27,7 +27,12 @@ module Graphql
       attr_reader :file_name, :mutation_name, :field_name
 
       def create_mutation_file
-        create_mutation_root_type
+        unless @behavior == :revoke
+          create_mutation_root_type
+        else
+          log :gsub, "#{options[:directory]}/types/mutation_type.rb"
+        end
+        
         template "mutation.erb", "#{options[:directory]}/mutations/#{file_name}.rb"
 
         sentinel = /name "Mutation"\s*\n/m

data/lib/generators/graphql/templates/function.erb

@@ -1,7 +1,7 @@
-class Functions::<%= name %> < GraphQL::Function
+class Functions::<%= class_name %> < GraphQL::Function
   # Define `initialize` to store field-level options, eg
   #
-  #     field :myField, function: Functions::<%= name %>.new(type: MyType)
+  #     field :myField, function: Functions::<%= class_name %>.new(type: MyType)
   #
   # attr_reader :type
   # def initialize(type:)

data/lib/generators/graphql/templates/loader.erb

@@ -1,7 +1,7 @@
-class Loaders::<%= name %> < GraphQL::Batch::Loader
+class Loaders::<%= class_name %> < GraphQL::Batch::Loader
   # Define `initialize` to store grouping arguments, eg
   #
-  #     Loaders::<%= name %>.for(group).load(value)
+  #     Loaders::<%= class_name %>.for(group).load(value)
   #
   # def initialize()
   # end

data/lib/graphql/execution.rb

@@ -2,6 +2,7 @@
 require "graphql/execution/directive_checks"
 require "graphql/execution/execute"
 require "graphql/execution/flatten"
+require "graphql/execution/instrumentation"
 require "graphql/execution/lazy"
 require "graphql/execution/multiplex"
 require "graphql/execution/typecast"

data/lib/graphql/execution/instrumentation.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Instrumentation
+      # This function implements the instrumentation policy:
+      #
+      # - Instrumenters are a stack; the first `before_query` will have the last `after_query`
+      # - If a `before_` hook returned without an error, its corresponding `after_` hook will run.
+      # - If the `before_` hook did _not_ run, the `after_` hook will not be called.
+      #
+      # When errors are raised from `after_` hooks:
+      #   - Subsequent `after_` hooks _are_ called
+      #   - The first raised error is captured; later errors are ignored
+      #   - If an error was capture, it's re-raised after all hooks are finished
+      #
+      # Partial runs of instrumentation are possible:
+      # - If a `before_multiplex` hook raises an error, no `before_query` hooks will run
+      # - If a `before_query` hook raises an error, subsequent `before_query` hooks will not run (on any query)
+      def self.apply_instrumenters(multiplex)
+        schema = multiplex.schema
+        queries = multiplex.queries
+        query_instrumenters = schema.instrumenters[:query]
+        multiplex_instrumenters = schema.instrumenters[:multiplex]
+
+        # First, run multiplex instrumentation, then query instrumentation for each query
+        call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
+          each_query_call_hooks(query_instrumenters, queries) do
+            # Let them be executed
+            yield
+          end
+        end
+      end
+
+      class << self
+        private
+        # Call the before_ hooks of each query,
+        # Then yield if no errors.
+        # `call_hooks` takes care of appropriate cleanup.
+        def each_query_call_hooks(instrumenters, queries, i = 0)
+          if i >= queries.length
+            yield
+          else
+            query = queries[i]
+            call_hooks(instrumenters, query, :before_query, :after_query) {
+              each_query_call_hooks(instrumenters, queries, i + 1) {
+                yield
+              }
+            }
+          end
+        end
+
+        # Call each before hook, and if they all succeed, yield.
+        # If they don't all succeed, call after_ for each one that succeeded.
+        def call_hooks(instrumenters, object, before_hook_name, after_hook_name, i = 0)
+          if i >= instrumenters.length
+            # We've reached the end of the instrumenters, so start exiting the call stack.
+            # (This will eventually call the originally-passed block.)
+            yield
+          else
+            # Get the next instrumenter and call the before_hook.
+            instrumenter = instrumenters[i]
+            instrumenter.public_send(before_hook_name, object)
+            # At this point, the before_hook did _not_ raise an error.
+            # (If it did raise an error, we wouldn't reach this point.)
+            # So we should guarantee that we run the after_hook.
+            begin
+              # Call the next instrumenter on the list,
+              # basically passing along the original block
+              call_hooks(instrumenters, object, before_hook_name, after_hook_name, i + 1) {
+                yield
+              }
+            ensure
+              # Regardless of how the next instrumenter in the list behaves,
+              # call the after_hook of this instrumenter
+              instrumenter.public_send(after_hook_name, object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/execution/multiplex.rb

@@ -60,12 +60,12 @@ module GraphQL
               if queries.length != 1
                 raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
               else
-                with_instrumentation(multiplex, max_complexity: max_complexity) do
+                instrument_and_analyze(multiplex, max_complexity: max_complexity) do
                   [run_one_legacy(schema, queries.first)]
                 end
               end
             else
-              with_instrumentation(multiplex, max_complexity: max_complexity) do
+              instrument_and_analyze(multiplex, max_complexity: max_complexity) do
                 run_as_multiplex(multiplex)
               end
             end
@@ -162,34 +162,17 @@ module GraphQL
         # Apply multiplex & query instrumentation to `queries`.
         #
         # It yields when the queries should be executed, then runs teardown.
-        def with_instrumentation(multiplex, max_complexity:)
-          schema = multiplex.schema
-          queries = multiplex.queries
-          query_instrumenters = schema.instrumenters[:query]
-          multiplex_instrumenters = schema.instrumenters[:multiplex]
-
-          # First, run multiplex instrumentation, then query instrumentation for each query
-          multiplex_instrumenters.each { |i| i.before_multiplex(multiplex) }
-          queries.each do |query|
-            query_instrumenters.each { |i| i.before_query(query) }
-          end
-
-          multiplex_analyzers = schema.multiplex_analyzers
-          if max_complexity
-            multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
-          end
-
-          GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
+        def instrument_and_analyze(multiplex, max_complexity:)
+          GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
+            schema = multiplex.schema
+            multiplex_analyzers = schema.multiplex_analyzers
+            if max_complexity
+              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)]
+            end
 
-          # Let them be executed
-          yield
-        ensure
-          # Finally, run teardown instrumentation for each query + the multiplex
-          # Use `reverse_each` so instrumenters are treated like a stack
-          queries.each do |query|
-            query_instrumenters.reverse_each { |i| i.after_query(query) }
+            GraphQL::Analysis.analyze_multiplex(multiplex, multiplex_analyzers)
+            yield
           end
-          multiplex_instrumenters.reverse_each { |i| i.after_multiplex(multiplex) }
         end
       end
     end

data/lib/graphql/field.rb

@@ -130,6 +130,7 @@ module GraphQL
       :relay_node_field,
       :relay_nodes_field,
       :subscription_scope,
+      :trace,
       argument: GraphQL::Define::AssignArgument
 
     ensure_defined(
@@ -186,6 +187,9 @@ module GraphQL
     # @return [nil, String] Prefix for subscription names from this field
     attr_accessor :subscription_scope
 
+    # @return [Boolean] True if this field should be traced. By default, fields are only traced if they are not a ScalarType or EnumType.
+    attr_accessor :trace
+
     # @return [Boolean]
     def connection?
       @connection
@@ -212,6 +216,7 @@ module GraphQL
       @connection = false
       @connection_max_page_size = nil
       @edge_class = nil
+      @trace = nil
     end
 
     def initialize_copy(other)

data/lib/graphql/internal_representation/node.rb

@@ -16,7 +16,7 @@ module GraphQL
       # This value is derived from {#scoped_children} after the rewrite is finished.
       # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>]
       def typed_children
-        @typed_childen ||= begin
+        @typed_children ||= begin
           new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
           if @scoped_children.any?
             all_object_types = Set.new

data/lib/graphql/language.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/language/definition_slice"
+require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"

data/lib/graphql/language/document_from_schema_definition.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    # @api private
+    #
+    # {GraphQL::Language::DocumentFromSchemaDefinition} is used to convert a {GraphQL::Schema} object
+    # To a {GraphQL::Language::Document} AST node.
+    #
+    class DocumentFromSchemaDefinition
+      def initialize(schema)
+        @schema = schema
+        @types = GraphQL::Schema::Traversal.new(schema, introspection: true).type_map.values
+      end
+
+      def document
+        GraphQL::Language::Nodes::Document.new(
+          definitions: build_definition_nodes
+        )
+      end
+
+      protected
+
+      def build_schema_node(schema)
+        schema_node = GraphQL::Language::Nodes::SchemaDefinition.new(
+          query: schema.query.name
+        )
+
+        if schema.mutation
+          schema_node.mutation = schema.mutation.name
+        end
+
+        if schema.subscription
+          schema_node.subscription = schema.subscription.name
+        end
+
+        schema_node
+      end
+
+      def build_object_type_node(object_type)
+        GraphQL::Language::Nodes::ObjectTypeDefinition.new(
+          name: object_type.name,
+          interfaces: object_type.interfaces.map { |iface| build_type_name_node(iface) },
+          fields: build_field_nodes(object_type.fields.values),
+          description: object_type.description,
+        )
+      end
+
+      def build_field_node(field)
+        GraphQL::Language::Nodes::FieldDefinition.new(
+          name: field.name,
+          arguments: build_argument_nodes(field.arguments.values),
+          type: build_type_name_node(field.type),
+          description: field.description,
+        )
+      end
+
+      def build_union_type_node(union_type)
+        GraphQL::Language::Nodes::UnionTypeDefinition.new(
+          name: union_type.name,
+          description: union_type.description,
+          types: union_type.possible_types.map { |type| build_type_name_node(type) }
+        )
+      end
+
+      def build_interface_type_node(interface_type)
+        GraphQL::Language::Nodes::InterfaceTypeDefinition.new(
+          name: interface_type.name,
+          description: interface_type.description,
+          fields: build_field_nodes(interface_type.fields.values)
+        )
+      end
+
+      def build_enum_type_node(enum_type)
+        GraphQL::Language::Nodes::EnumTypeDefinition.new(
+          name: enum_type.name,
+          values: enum_type.values.values.map do |enum_value|
+            build_enum_value_node(enum_value)
+          end,
+          description: enum_type.description,
+        )
+      end
+
+      def build_enum_value_node(enum_value)
+        GraphQL::Language::Nodes::EnumValueDefinition.new(
+          name: enum_value.name,
+          description: enum_value.description,
+        )
+      end
+
+      def build_scalar_type_node(scalar_type)
+        GraphQL::Language::Nodes::ScalarTypeDefinition.new(
+          name: scalar_type.name,
+          description: scalar_type.description,
+        )
+      end
+
+      def build_argument_node(argument)
+        GraphQL::Language::Nodes::InputValueDefinition.new(
+          name: argument.name,
+          description: argument.description,
+          type: build_type_name_node(argument.type),
+          default_value: argument.default_value,
+        )
+      end
+
+      def build_input_object_node(input_object)
+        GraphQL::Language::Nodes::InputObjectTypeDefinition.new(
+          name: input_object.name,
+          fields: build_argument_nodes(input_object.arguments.values),
+          description: input_object.description,
+        )
+      end
+
+      def build_directive_node(directive)
+        GraphQL::Language::Nodes::DirectiveDefinition.new(
+          name: directive.name,
+          arguments: build_argument_nodes(directive.arguments.values),
+          locations: directive.locations.map(&:to_s),
+          description: directive.description,
+        )
+      end
+
+      def build_type_name_node(type)
+        case type
+        when GraphQL::ListType
+          GraphQL::Language::Nodes::ListType.new(
+            of_type: build_type_name_node(type.of_type)
+          )
+        when GraphQL::NonNullType
+          GraphQL::Language::Nodes::NonNullType.new(
+            of_type: build_type_name_node(type.of_type)
+          )
+        else
+          GraphQL::Language::Nodes::TypeName.new(name: type.name)
+        end
+      end
+
+      def build_type_definition_node(type)
+        case type
+        when GraphQL::ObjectType
+          build_object_type_node(type)
+        when GraphQL::UnionType
+          build_union_type_node(type)
+        when GraphQL::InterfaceType
+          build_interface_type_node(type)
+        when GraphQL::ScalarType
+          build_scalar_type_node(type)
+        when GraphQL::EnumType
+          build_enum_type_node(type)
+        when GraphQL::InputObjectType
+          build_input_object_node(type)
+        else
+          raise TypeError
+        end
+      end
+
+      def build_argument_nodes(arguments)
+        arguments.map { |arg| build_argument_node(arg) }
+      end
+
+      def build_directive_nodes(directives)
+        directives.map { |directive| build_directive_node(directive) }
+      end
+
+      def build_definition_nodes
+        definitions = build_type_definition_nodes(types)
+        definitions += build_directive_nodes(schema.directives.values)
+        definitions << build_schema_node(schema)
+        definitions
+      end
+
+      def build_type_definition_nodes(types)
+        types.map { |type| build_type_definition_node(type) }
+      end
+
+      def build_field_nodes(fields)
+        fields.map { |field| build_field_node(field) }
+      end
+
+      private
+
+      attr_reader :schema, :types
+    end
+  end
+end