graphql 0.18.4 → 0.18.5

data/lib/graphql/query.rb

@@ -50,7 +50,6 @@ module GraphQL
       @operations = {}
       @provided_variables = variables
       @query_string = query_string
-
       @document = document || GraphQL.parse(query_string)
       @document.definitions.each do |part|
         if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)

data/lib/graphql/query/arguments.rb

@@ -14,7 +14,7 @@ module GraphQL
         end
       end
 
-      # @param [String, Symbol] name or index of value to access
+      # @param key [String, Symbol] name or index of value to access
       # @return [Object] the argument at that key
       def [](key)
         @argument_values[key.to_s]

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

@@ -54,7 +54,9 @@ module GraphQL
 
         class HasPossibleTypeResolution < BaseResolution
           def non_null_result
-            resolved_type = field_type.resolve_type(value, execution_context)
+            # When deprecations are removed:
+            # resolved_type = execution_context.schema.resolve_type(value)
+            resolved_type = field_type.legacy_resolve_type(value, execution_context)
 
             unless resolved_type.is_a?(GraphQL::ObjectType)
               raise GraphQL::ObjectType::UnresolvedTypeError.new(irep_node.definition_name, field_type, parent_type)

data/lib/graphql/relay/global_node_identification.rb

@@ -12,6 +12,10 @@ module GraphQL
       accepts_definitions(:object_from_id, :type_from_object, :to_global_id, :from_global_id, :description)
       lazy_defined_attr_accessor :description
 
+      # Memoize the schema to support deprecated node_ident-level resolve functions
+      # TODO: remove after Schema.resolve_type is required
+      attr_accessor :schema
+
       class << self
         attr_accessor :id_separator
       end
@@ -28,12 +32,20 @@ module GraphQL
         @interface ||= begin
           ensure_defined
           ident = self
-          GraphQL::InterfaceType.define do
-            name "Node"
-            field :id, !types.ID
-            resolve_type -> (obj, schema) {
-              ident.type_from_object(obj)
-            }
+          if @type_from_object_proc
+            # TODO: remove after Schema.resolve_type is required
+            GraphQL::InterfaceType.define do
+              name "Node"
+              field :id, !types.ID
+              resolve_type -> (obj, ctx) {
+                ident.type_from_object(obj)
+              }
+            end
+          else
+            GraphQL::InterfaceType.define do
+              name "Node"
+              field :id, !types.ID
+            end
           end
         end
       end
@@ -90,22 +102,23 @@ module GraphQL
 
       # Use the provided config to
       # get a type for a given object
+      # TODO: remove after Schema.resolve_type is required
       def type_from_object(object)
         ensure_defined
-        type_result = @type_from_object_proc.call(object)
-        if type_result.nil?
-          nil
-        elsif !type_result.is_a?(GraphQL::BaseType)
-          type_str = "#{type_result} (#{type_result.class.name})"
-          raise "type_from_object(#{object}) returned #{type_str}, but it should return a GraphQL type"
-        else
-          type_result
+        warn("type_from_object(object) is deprecated; use Schema.resolve_type(object) instead")
+
+        if @type_from_object_proc
+          schema.resolve_type = @type_from_object_proc
+          @type_from_object_proc = nil
         end
+
+        schema.resolve_type(object)
       end
 
-      def type_from_object=(proc)
+      def type_from_object=(new_type_from_object_proc)
         ensure_defined
-        @type_from_object_proc = proc
+        warn("type_from_object(object) is deprecated; use Schema.resolve_type(object) instead")
+        @type_from_object_proc = new_type_from_object_proc
       end
 
       # Use the provided config to

data/lib/graphql/scalar_type.rb

@@ -1,5 +1,28 @@
 module GraphQL
-  # The parent type for scalars, eg {GraphQL::STRING_TYPE}, {GraphQL::INT_TYPE}
+  # # GraphQL::ScalarType
+  #
+  # Scalars are plain values. They are leaf nodes in a GraphQL query tree.
+  #
+  # ## Built-in Scalars
+  #
+  # `GraphQL` comes with standard built-in scalars:
+  #
+  # |Constant | `.define` helper|
+  # |-------|--------|
+  # |`GraphQL::STRING_TYPE` | `types.String`|
+  # |`GraphQL::INT_TYPE` | `types.Int`|
+  # |`GraphQL::FLOAT_TYPE` | `types.Float`|
+  # |`GraphQL::ID_TYPE` | `types.ID`|
+  # |`GraphQL::BOOLEAN_TYPE` | `types.Boolean`|
+  #
+  # (`types` is an instance of `GraphQL::Definition::TypeDefiner`; `.String`, `.Float`, etc are methods which return built-in scalars.)
+  #
+  # ## Custom Scalars
+  #
+  # You can define custom scalars for your GraphQL server. It requires some special functions:
+  #
+  # - `coerce_input` is used to prepare incoming values for GraphQL execution. (Incoming values come from variables or literal values in the query string.)
+  # - `coerce_result` is used to turn Ruby values _back_ into serializable values for query responses.
   #
   # @example defining a type for Time
   #   TimeType = GraphQL::ScalarType.define do

data/lib/graphql/schema.rb

@@ -11,33 +11,88 @@ require "graphql/schema/validation"
 
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
+  #
+  # The {Schema} contains:
+  #
+  #  - types for exposing your application
+  #  - query analyzers for assessing incoming queries (including max depth & max complexity restrictions)
+  #  - execution strategies for running incoming queries
+  #  - middleware for interacting with execution
+  #
+  # Schemas start with root types, {Schema#query}, {Schema#mutation} and {Schema#subscription}.
+  # The schema will traverse the tree of fields & types, using those as starting points.
+  # Any undiscoverable types may be provided with the `types` configuration.
+  #
+  # Schemas can restrict large incoming queries with `max_depth` and `max_complexity` configurations.
+  # (These configurations can be overridden by specific calls to {Schema#execute})
+  #
+  # Schemas can specify how queries should be executed against them.
+  # `query_execution_strategy`, `mutation_execution_strategy` and `subscription_execution_strategy`
+  # each apply to corresponding root types.
+  #
+  # A schema accepts a `Relay::GlobalNodeIdentification` instance for use with Relay IDs.
+  #
+  # @example defining a schema
+  #   MySchema = GraphQL::Schema.define do
+  #     query QueryType
+  #     middleware PermissionMiddleware
+  #     rescue_from(ActiveRecord::RecordNotFound) { "Not found" }
+  #     # If types are only connected by way of interfaces, they must be added here
+  #     orphan_types ImageType, AudioType
+  #   end
+  #
   class Schema
-    extend Forwardable
+    include GraphQL::Define::InstanceDefinable
+    accepts_definitions \
+      :query, :mutation, :subscription,
+      :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
+      :max_depth, :max_complexity,
+      :node_identification,
+      :orphan_types, :resolve_type,
+      query_analyzer: -> (schema, analyzer) { schema.query_analyzers << analyzer },
+      middleware: -> (schema, middleware) { schema.middleware << middleware },
+      rescue_from: -> (schema, err_class, &block) { schema.rescue_from(err_class, &block)}
+
+    lazy_defined_attr_accessor \
+      :query, :mutation, :subscription,
+      :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
+      :max_depth, :max_complexity,
+      :orphan_types,
+      :query_analyzers, :middleware
+
 
     DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
+    RESOLVE_TYPE_PROC_REQUIRED = -> (obj) { raise("Schema.resolve_type is undefined, can't resolve type for #{obj}") }
 
-    attr_reader :query, :mutation, :subscription, :directives, :static_validator, :query_analyzers
-    attr_accessor :max_depth
-    attr_accessor :max_complexity
-
-    # Override these if you don't want the default executor:
-    attr_accessor :query_execution_strategy,
-      :mutation_execution_strategy,
-      :subscription_execution_strategy
+    attr_reader :directives, :static_validator
 
     # @return [GraphQL::Relay::GlobalNodeIdentification] the node identification instance for this schema, when using Relay
-    attr_accessor :node_identification
+    def node_identification
+      ensure_defined
+      @node_identification
+    end
+
+    def node_identification=(new_node_ident)
+      new_node_ident.schema = self
+      @node_identification = new_node_ident
+    end
 
     # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
-    attr_reader :middleware
+    def middleware
+      ensure_defined
+      @middleware
+    end
 
     # @param query [GraphQL::ObjectType]  the query root for the schema
     # @param mutation [GraphQL::ObjectType] the mutation root for the schema
     # @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:, mutation: nil, subscription: nil, max_depth: nil, max_complexity: nil, types: [])
+    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
@@ -49,18 +104,28 @@ module GraphQL
       @rescue_middleware = GraphQL::Schema::RescueMiddleware.new
       @middleware = [@rescue_middleware]
       @query_analyzers = []
+      @resolve_type_proc = RESOLVE_TYPE_PROC_REQUIRED
       # Default to the built-in execution strategy:
-      self.query_execution_strategy = GraphQL::Query::SerialExecution
-      self.mutation_execution_strategy = GraphQL::Query::SerialExecution
-      self.subscription_execution_strategy = GraphQL::Query::SerialExecution
+      @query_execution_strategy = GraphQL::Query::SerialExecution
+      @mutation_execution_strategy = GraphQL::Query::SerialExecution
+      @subscription_execution_strategy = GraphQL::Query::SerialExecution
+    end
+
+    def rescue_from(*args, &block)
+      ensure_defined
+      @rescue_middleware.rescue_from(*args, &block)
     end
 
-    def_delegators :@rescue_middleware, :rescue_from, :remove_handler
+    def remove_handler(*args, &block)
+      ensure_defined
+      @rescue_middleware.remove_handler(*args, &block)
+    end
 
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
     def types
       @types ||= begin
-        all_types = @orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
+        ensure_defined
+        all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
         GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
       end
     end
@@ -69,13 +134,14 @@ module GraphQL
     # See {Query#initialize} for arguments.
     # @return [Hash] query result, ready to be serialized as JSON
     def execute(*args)
-      query = GraphQL::Query.new(self, *args)
-      query.result
+      query_obj = GraphQL::Query.new(self, *args)
+      query_obj.result
     end
 
     # Resolve field named `field_name` for type `parent_type`.
     # Handles dynamic fields `__typename`, `__type` and `__schema`, too
     def get_field(parent_type, field_name)
+      ensure_defined
       defined_field = parent_type.get_field(field_name)
       if defined_field
         defined_field
@@ -91,12 +157,15 @@ module GraphQL
     end
 
     def type_from_ast(ast_node)
+      ensure_defined
       GraphQL::Schema::TypeExpression.build_type(self, ast_node)
     end
 
+    # TODO: when `resolve_type` is schema level, can this be removed?
     # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
     def possible_types(type_defn)
+      ensure_defined
       @interface_possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
       @interface_possible_types.possible_types(type_defn)
     end
@@ -126,5 +195,26 @@ module GraphQL
         raise ArgumentError, "unknown operation type: #{operation}"
       end
     end
+
+    # Determine the GraphQL type for a given object.
+    # This is required for unions and interfaces (include Relay's node interface)
+    # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
+    def resolve_type(object, ctx)
+      ensure_defined
+      type_result = @resolve_type_proc.call(object, ctx)
+      if type_result.nil?
+        nil
+      elsif !type_result.is_a?(GraphQL::BaseType)
+        type_str = "#{type_result} (#{type_result.class.name})"
+        raise "resolve_type(#{object}) returned #{type_str}, but it should return a GraphQL type"
+      else
+        type_result
+      end
+    end
+
+    def resolve_type=(new_resolve_type_proc)
+      ensure_defined
+      @resolve_type_proc = new_resolve_type_proc
+    end
   end
 end

data/lib/graphql/schema/printer.rb

@@ -3,8 +3,8 @@ module GraphQL
     # Used to convert your {GraphQL::Schema} to a GraphQL schema string
     #
     # @example print your schema to standard output
-    #   Schema = GraphQL::Schema.new(query: QueryType)
-    #   puts GraphQL::Schema::Printer.print_schema(Schema)
+    #   MySchema = GraphQL::Schema.define(query: QueryType)
+    #   puts GraphQL::Schema::Printer.print_schema(MySchema)
     #
     module Printer
       extend self
@@ -20,7 +20,7 @@ module GraphQL
         query_root = ObjectType.define do
           name "Query"
         end
-        schema = Schema.new(query: query_root)
+        schema = GraphQL::Schema.define(query: query_root)
         print_filtered_schema(schema, method(:is_introspection_type))
       end
 

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

@@ -10,7 +10,7 @@ module GraphQL
         if !valid
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
-          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value", parent, context: context)
+          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.", parent, context: context)
         end
       end
     end

data/lib/graphql/union_type.rb

@@ -1,14 +1,27 @@
 module GraphQL
-  # A collection of {ObjectType}s
+  # A Union is is a collection of object types which may appear in the same place.
   #
-  # @example a union of types
+  # The members of a union are declared with `possible_types`.
   #
-  #   PetUnion = GraphQL::UnionType.define do
-  #     name "Pet"
-  #     description "Animals that live in your house"
-  #     possible_types [DogType, CatType, FishType]
+  # @example A union of object types
+  #   MediaUnion = GraphQL::UnionType.define do
+  #     name "Media"
+  #     description "Media objects which you can enjoy"
+  #     possible_types [AudioType, ImageType, VideoType]
   #   end
   #
+  # A union itself has no fields; only its members have fields.
+  # So, when you query, you must use fragment spreads to access fields.
+  #
+  # @example Querying for fields on union members
+  #  {
+  #    searchMedia(name: "Jens Lekman") {
+  #      ... on Audio { name, duration }
+  #      ... on Image { name, height, width }
+  #      ... on Video { name, length, quality }
+  #    }
+  #  }
+  #
   class UnionType < GraphQL::BaseType
     include GraphQL::BaseType::HasPossibleTypes
     accepts_definitions :possible_types, :resolve_type

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.18.4"
+  VERSION = "0.18.5"
 end

data/readme.md

@@ -62,10 +62,10 @@ QueryType = GraphQL::ObjectType.define do
 end
 
 # Then create your schema
-Schema = GraphQL::Schema.new(
-  query: QueryType,
-  max_depth: 8,
-)
+Schema = GraphQL::Schema.define do
+  query QueryType,
+  max_depth 8,
+end
 ```
 
 #### Execute queries
@@ -127,10 +127,9 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - Reduce ad-hoc traversals?
   - Validators are order-dependent, is this a smell?
   - Tests for interference between validators are poor
-  - Maybe this is a candidate for a rewrite? Can it somehow work more closely with query analysis? Somehow support the `Query#perform_validation` refactor?
+  - Maybe this is a candidate for a rewrite?
 - Add Rails-y argument validations, eg `less_than: 100`, `max_length: 255`, `one_of: [...]`
   - Must be customizable
-- Refactor `Query#perform_validation`, how can that be organized better?
 - Relay:
   - `GlobalNodeIdentification.to_global_id` should receive the type name and _object_, not `id`. (Or, maintain the "`type_name, id` in, `type_name, id` out" pattern?)
   - Reduce duplication in ArrayConnection / RelationConnection

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -255,7 +255,7 @@ describe GraphQL::Analysis::QueryComplexity do
         end
       end
 
-      GraphQL::Schema.new(query: query_type, types: [double_complexity_type])
+      GraphQL::Schema.define(query: query_type, orphan_types: [double_complexity_type])
     }
     let(:query_string) {%|
       {

data/spec/graphql/argument_spec.rb

@@ -10,7 +10,7 @@ describe GraphQL::Argument do
     end
 
     err = assert_raises(GraphQL::Schema::InvalidTypeError) {
-      schema = GraphQL::Schema.new(query: query_type)
+      schema = GraphQL::Schema.define(query: query_type)
       schema.types
     }
 

data/spec/graphql/field_spec.rb

@@ -82,7 +82,7 @@ describe GraphQL::Field do
       invalid_field.name = :symbol_name
 
       dummy_query.fields["symbol_name"] = invalid_field
-      dummy_schema = GraphQL::Schema.new(query: dummy_query)
+      dummy_schema = GraphQL::Schema.define(query: dummy_query)
 
       err = assert_raises(GraphQL::Schema::InvalidTypeError) { dummy_schema.types }
       assert_equal "QueryType is invalid: field :symbol_name name must return String, not Symbol (:symbol_name)", err.message