graphql 1.4.5 → 1.5.3

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

@@ -23,11 +23,14 @@ 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.name
-            fragment_child = context.warden.get_type(fragment_child_name)
-            # 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)
+            frag_node = context.fragments[frag_spread.node.name]
+            if frag_node
+              fragment_child_name = frag_node.type.name
+              fragment_child = context.warden.get_type(fragment_child_name)
+              # 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)
+              end
             end
           end
         }

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

@@ -5,38 +5,13 @@ module GraphQL
       include GraphQL::StaticValidation::Message::MessageHelper
 
       def validate(context)
-        context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << ->(node, parent) {
-          if has_nested_spread?(node, [], context)
-            context.errors << message("Fragment #{node.name} contains an infinite loop", node, context: context)
+        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(_n, _p) do
+          dependency_map = context.dependencies
+          dependency_map.cyclical_definitions.each do |defn|
+            if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+              context.errors << message("Fragment #{defn.name} contains an infinite loop", defn.node, path: defn.path)
+            end
           end
-        }
-      end
-
-      private
-
-      def has_nested_spread?(fragment_def, parent_fragment_names, context)
-        nested_spreads = get_spreads(fragment_def.selections)
-
-        nested_spreads.any? do |spread|
-          nested_def = context.fragments[spread.name]
-          if nested_def.nil?
-            # this is another kind of error
-            false
-          else
-            parent_fragment_names.include?(spread.name) || has_nested_spread?(nested_def, parent_fragment_names + [fragment_def.name], context)
-          end
-        end
-      end
-
-      # Find spreads contained in this selection & return them in a flat array
-      def get_spreads(selection)
-        case selection
-        when GraphQL::Language::Nodes::FragmentSpread
-          [selection]
-        when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InlineFragment
-          get_spreads(selection.selections)
-        when Array
-          selection.map { |s| get_spreads(s) }.flatten
         end
       end
     end

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

@@ -5,49 +5,19 @@ module GraphQL
       include GraphQL::StaticValidation::Message::MessageHelper
 
       def validate(context)
-        v = context.visitor
-        used_fragments = []
-        defined_fragments = []
-
-        v[GraphQL::Language::Nodes::Document] << ->(node, parent) {
-          defined_fragments = node.definitions
-            .select { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
-            .map { |node| FragmentInstance.new(node: node, path: context.path) }
-        }
-
-        v[GraphQL::Language::Nodes::FragmentSpread] << ->(node, parent) {
-          used_fragments << FragmentInstance.new(node: node, path: context.path)
-          if defined_fragments.none? { |defn| defn.name == node.name }
-            GraphQL::Language::Visitor::SKIP
+        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(_n, _p) do
+          dependency_map = context.dependencies
+          dependency_map.unmet_dependencies.each do |op_defn, spreads|
+            spreads.each do |fragment_spread|
+              context.errors << message("Fragment #{fragment_spread.name} was used, but not defined", fragment_spread.node, path: fragment_spread.path)
+            end
           end
-        }
-        v[GraphQL::Language::Nodes::Document].leave << ->(node, parent) { add_errors(context, used_fragments, defined_fragments) }
-      end
-
-      private
-
-      def add_errors(context, used_fragments, defined_fragments)
-        undefined_fragments = find_difference(used_fragments, defined_fragments.map(&:name))
-        undefined_fragments.each do |fragment|
-          context.errors << message("Fragment #{fragment.name} was used, but not defined", fragment.node, path: fragment.path)
-        end
 
-        unused_fragments = find_difference(defined_fragments, used_fragments.map(&:name))
-        unused_fragments.each do |fragment|
-          context.errors << message("Fragment #{fragment.name} was defined, but not used", fragment.node, path: fragment.path)
-        end
-      end
-
-      def find_difference(fragments, allowed_fragment_names)
-        fragments.select {|f| f.name && !allowed_fragment_names.include?(f.name) }
-      end
-
-      class FragmentInstance
-        attr_reader :name, :node, :path
-        def initialize(node:, path:)
-          @node = node
-          @name = node.name
-          @path = path
+          dependency_map.unused_dependencies.each do |fragment|
+            if !fragment.name.nil?
+              context.errors << message("Fragment #{fragment.name} was defined, but not used", fragment.node, path: fragment.path)
+            end
+          end
         end
       end
     end

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

@@ -7,11 +7,11 @@ module GraphQL
       def validate(context)
         op_names = Hash.new { |h, k| h[k] = [] }
 
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition].enter << -> (node, _parent) {
+        context.visitor[GraphQL::Language::Nodes::OperationDefinition].enter << ->(node, _parent) {
           op_names[node.name] << node
         }
 
-        context.visitor[GraphQL::Language::Nodes::Document].leave << -> (node, _parent) {
+        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(node, _parent) {
           op_count = op_names.values.inject(0) { |m, v| m += v.size }
 
           op_names.each do |name, nodes|

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

@@ -33,7 +33,10 @@ module GraphQL
       private
 
       def validate_usage(arguments, arg_node, ast_var, context)
-        var_type = to_query_type(ast_var.type, context.schema.types)
+        var_type = to_query_type(ast_var.type, context.query.warden)
+        if var_type.nil?
+          return
+        end
         if !ast_var.default_value.nil?
           var_type = GraphQL::NonNullType.new(of_type: var_type)
         end
@@ -53,13 +56,22 @@ module GraphQL
         end
       end
 
-      def to_query_type(ast_type, types)
-        if ast_type.is_a?(GraphQL::Language::Nodes::NonNullType)
-          GraphQL::NonNullType.new(of_type: to_query_type(ast_type.of_type, types))
-        elsif ast_type.is_a?(GraphQL::Language::Nodes::ListType)
-          GraphQL::ListType.new(of_type: to_query_type(ast_type.of_type, types))
+      def to_query_type(ast_type, warden)
+        case ast_type
+        when GraphQL::Language::Nodes::NonNullType
+          wrap_query_type(to_query_type(ast_type.of_type, warden), GraphQL::NonNullType)
+        when GraphQL::Language::Nodes::ListType
+          wrap_query_type(to_query_type(ast_type.of_type, warden), GraphQL::ListType)
+        else
+          warden.get_type(ast_type.name)
+        end
+      end
+
+      def wrap_query_type(type, wrapper)
+        if type.nil?
+          nil
         else
-          types[ast_type.name]
+          wrapper.new(of_type: type)
         end
       end
 

data/lib/graphql/static_validation/validation_context.rb

@@ -12,7 +12,11 @@ module GraphQL
     # It also provides limited access to the {TypeStack} instance,
     # which tracks state as you climb in and out of different fields.
     class ValidationContext
-      attr_reader :query, :schema, :document, :errors, :visitor, :fragments, :operations, :warden
+      attr_reader :query, :schema,
+        :document, :errors, :visitor,
+        :fragments, :operations, :warden,
+        :dependencies, :each_irep_node_handlers
+
       def initialize(query)
         @query = query
         @schema = query.schema
@@ -33,12 +37,29 @@ module GraphQL
         @errors = []
         @visitor = GraphQL::Language::Visitor.new(document)
         @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
+        definition_dependencies = DefinitionDependencies.mount(self)
+        @on_dependency_resolve_handlers = []
+        @each_irep_node_handlers = []
+        visitor[GraphQL::Language::Nodes::Document].leave << ->(_n, _p) {
+          @dependencies = definition_dependencies.dependency_map { |defn, spreads, frag|
+            @on_dependency_resolve_handlers.each { |h| h.call(defn, spreads, frag) }
+          }
+        }
+      end
+
+
+      def on_dependency_resolve(&handler)
+        @on_dependency_resolve_handlers << handler
       end
 
       def object_types
         @type_stack.object_types
       end
 
+      def each_irep_node(&handler)
+        @each_irep_node_handlers << handler
+      end
+
       # @return [GraphQL::BaseType] The current object type
       def type_definition
         object_types.last

data/lib/graphql/static_validation/validator.rb

@@ -32,11 +32,14 @@ module GraphQL
         end
 
         context.visitor.visit
+        # Post-validation: allow validators to register handlers on rewritten query nodes
+        rewrite_result = rewrite.operations
+        GraphQL::InternalRepresentation::Visit.visit_each_node(rewrite_result, context.each_irep_node_handlers)
 
         {
           errors: context.errors,
           # If there were errors, the irep is garbage
-          irep: context.errors.none? ? rewrite.operations : nil,
+          irep: context.errors.any? ? nil : rewrite_result,
         }
       end
     end

data/lib/graphql/string_type.rb

@@ -3,7 +3,11 @@ GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
   name "String"
   description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
 
-  coerce_result ->(value) { value.to_s }
+  coerce_result ->(value) {
+    str = value.to_s
+    str.encoding == Encoding::US_ASCII || str.encoding == Encoding::UTF_8 ? str : nil
+  }
+
   coerce_input ->(value) { value.is_a?(String) ? value : nil }
   default_scalar true
 end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.4.5"
+  VERSION = "1.5.3"
 end

data/readme.md

@@ -8,8 +8,9 @@
 
 A Ruby implementation of [GraphQL](http://graphql.org/).
 
- - [Website](https://rmosolgo.github.io/graphql-ruby)
- - [API Documentation](http://www.rubydoc.info/github/rmosolgo/graphql-ruby)
+- [Website](https://rmosolgo.github.io/graphql-ruby)
+- [API Documentation](http://www.rubydoc.info/github/rmosolgo/graphql-ruby)
+- [Newsletter](https://tinyletter.com/graphql-ruby)
 
 ## Installation
 
@@ -26,7 +27,15 @@ $ bundle install
 
 ## Getting Started
 
-See "Getting Started" on the [website](https://rmosolgo.github.io/graphql-ruby/) or on [GitHub](https://github.com/rmosolgo/graphql-ruby/blob/master/guides/index.md)
+```
+$ rails generate graphql:install
+```
+
+Or, see ["Getting Started"](https://rmosolgo.github.io/graphql-ruby/).
+
+## Upgrade
+
+I also sell [GraphQL::Pro](http://graphql.pro) which provides several features on top of the GraphQL runtime, including [authorization](http://rmosolgo.github.io/graphql-ruby/pro/authorization), [monitoring](http://rmosolgo.github.io/graphql-ruby/pro/monitoring) plugins and [static queries](http://rmosolgo.github.io/graphql-ruby/pro/persisted_queries). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
 
 ## Goals
 

data/spec/generators/graphql/enum_generator_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/enum_generator"
+
+class GraphQLGeneratorsEnumGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::EnumGenerator
+
+  test "it generate enums with values" do
+    expected_content = <<-RUBY
+Types::FamilyType = GraphQL::EnumType.define do
+  name "Family"
+  value "NIGHTSHADE"
+  value "BRASSICA", value: Family::COLE
+  value "UMBELLIFER", value: :umbellifer
+  value "LEGUME", value: "bean & friends"
+  value "CURCURBITS", value: 5
+end
+RUBY
+
+    run_generator(["Family",
+      "NIGHTSHADE",
+      "BRASSICA:Family::COLE",
+      "UMBELLIFER::umbellifer",
+      'LEGUME:"bean & friends"',
+      "CURCURBITS:5"
+    ])
+    assert_file "app/graphql/types/family_type.rb", expected_content
+  end
+end

data/spec/generators/graphql/function_generator_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/function_generator"
+
+class GraphQLGeneratorsFunctionGeneratorTest < BaseGeneratorTest
+  tests Graphql::Generators::FunctionGenerator
+
+  test "it generates an empty function by name" do
+    run_generator(["FindRecord"])
+
+    expected_content = <<-RUBY
+class Functions::FindRecord < GraphQL::Function
+  # Define `initialize` to store field-level options, eg
+  #
+  #     field :myField, function: Functions::FindRecord.new(type: MyType)
+  #
+  # attr_reader :type
+  # def initialize(type:)
+  #   @type = type
+  # end
+
+  # add arguments by type:
+  # argument :id, !GraphQL::ID_TYPE
+
+  # Resolve function:
+  def call(obj, args, ctx)
+  end
+end
+RUBY
+
+    assert_file "app/graphql/functions/find_record.rb", expected_content
+  end
+end

data/spec/generators/graphql/install_generator_spec.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "generators/graphql/install_generator"
+
+class GraphQLGeneratorsInstallGeneratorTest < Rails::Generators::TestCase
+
+  tests Graphql::Generators::InstallGenerator
+  destination File.expand_path("../../../tmp/dummy", File.dirname(__FILE__))
+
+  setup do
+    prepare_destination
+    FileUtils.cd(File.expand_path("../../../tmp", File.dirname(__FILE__))) do
+      `rm -rf dummy`
+      `rails new dummy --skip-active-record --skip-test-unit --skip-spring --skip-bundle`
+    end
+  end
+
+  test "it generates a folder structure" do
+    run_generator([])
+
+    assert_file "app/graphql/types/.keep"
+    assert_file "app/graphql/mutations/.keep"
+    expected_query_route = %|post "/graphql", to: "graphql#execute"|
+    expected_graphiql_route = %|
+  if Rails.env.development?
+    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+  end
+|
+
+    assert_file "config/routes.rb" do |contents|
+      assert_includes contents, expected_query_route
+      assert_includes contents, expected_graphiql_route
+    end
+
+    assert_file "Gemfile" do |contents|
+      assert_match %r{gem ('|")graphiql-rails('|"), :?group(:| =>) :development}, contents
+    end
+
+    expected_schema = <<-RUBY
+DummySchema = GraphQL::Schema.define do
+  query(Types::QueryType)
+end
+RUBY
+    assert_file "app/graphql/dummy_schema.rb", expected_schema
+
+
+    expected_query_type = <<-RUBY
+Types::QueryType = GraphQL::ObjectType.define do
+  name "Query"
+  # Add root-level fields here.
+  # They will be entry points for queries on your schema.
+
+  # TODO: remove me
+  field :testField, types.String do
+    description \"An example field added by the generator\"
+    resolve ->(obj, args, ctx) {
+      \"Hello World!\"
+    }
+  end
+end
+RUBY
+
+    assert_file "app/graphql/types/query_type.rb", expected_query_type
+    assert_file "app/controllers/graphql_controller.rb", EXPECTED_GRAPHQLS_CONTROLLER
+  end
+
+  test "it generates graphql-batch and relay boilerplate" do
+    run_generator(["--batch", "--relay"])
+    assert_file "app/graphql/loaders/.keep"
+    assert_file "Gemfile" do |contents|
+      assert_match %r{gem ('|")graphql-batch('|")}, contents
+    end
+
+    expected_query_type = <<-RUBY
+Types::QueryType = GraphQL::ObjectType.define do
+  name "Query"
+  # Add root-level fields here.
+  # They will be entry points for queries on your schema.
+
+  # TODO: remove me
+  field :testField, types.String do
+    description \"An example field added by the generator\"
+    resolve ->(obj, args, ctx) {
+      \"Hello World!\"
+    }
+  end
+
+  field :node, GraphQL::Relay::Node.field
+end
+RUBY
+
+    assert_file "app/graphql/types/query_type.rb", expected_query_type
+    assert_file "app/graphql/dummy_schema.rb", EXPECTED_RELAY_BATCH_SCHEMA
+  end
+
+  test "it can skip keeps, skip graphiql and customize schema name" do
+    run_generator(["--skip-keeps", "--skip-graphiql", "--schema=CustomSchema"])
+    assert_no_file "app/graphql/types/.keep"
+    assert_no_file "app/graphql/mutations/.keep"
+    assert_file "app/graphql/types"
+    assert_file "app/graphql/mutations"
+    assert_file "Gemfile" do |contents|
+      refute_includes contents, "graphiql-rails"
+    end
+
+    assert_file "config/routes.rb" do |contents|
+      refute_includes contents, "GraphiQL::Rails"
+    end
+
+    assert_file "app/graphql/custom_schema.rb", /CustomSchema = GraphQL::Schema\.define/
+    assert_file "app/controllers/graphql_controller.rb", /CustomSchema\.execute/
+  end
+
+  EXPECTED_GRAPHQLS_CONTROLLER = <<-RUBY
+class GraphqlController < ApplicationController
+  def execute
+    variables = ensure_hash(params[:variables])
+    query = params[:query]
+    context = {
+      # Query context goes here, for example:
+      # current_user: current_user,
+    }
+    result = DummySchema.execute(query, variables: variables, context: context)
+    render json: result
+  end
+
+  private
+
+  # Handle form data, JSON body, or a blank value
+  def ensure_hash(ambiguous_param)
+    case ambiguous_param
+    when String
+      if ambiguous_param.present?
+        ensure_hash(JSON.parse(ambiguous_param))
+      else
+        {}
+      end
+    when Hash, ActionController::Parameters
+      ambiguous_param
+    when nil
+      {}
+    else
+      raise ArgumentError, "Unexpected parameter: \#{ambiguous_param}"
+    end
+  end
+end
+RUBY
+
+  EXPECTED_RELAY_BATCH_SCHEMA = <<-RUBY
+DummySchema = GraphQL::Schema.define do
+  query(Types::QueryType)
+
+  # Relay Object Identification:
+
+  # Return a string UUID for `object`
+  id_from_object ->(object, type_definition, query_ctx) {
+    # Here's a simple implementation which:
+    # - joins the type name & object.id
+    # - encodes it with base64:
+    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+  }
+
+  # Given a string UUID, find the object
+  object_from_id ->(id, query_ctx) {
+    # For example, to decode the UUIDs generated above:
+    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
+    #
+    # Then, based on `type_name` and `id`
+    # find an object in your application
+    # ...
+  }
+
+  # Object Resolution
+  resolve_type -> (obj, ctx) {
+    # TODO: Implement this function
+    # to return the correct type for `obj`
+    raise(NotImplementedError)
+  }
+
+  # GraphQL::Batch setup:
+  lazy_resolve(Promise, :sync)
+  instrument(:query, GraphQL::Batch::Setup)
+end
+RUBY
+end