graphql 1.8.0.pre7 → 1.8.0.pre8

data/lib/graphql/language/parser.y

@@ -152,10 +152,6 @@ rule
     | operation_type
     | schema_keyword
 
-  name_list:
-      name             { return [make_node(:TypeName, name: val[0])] }
-    | name_list name   { val[0] << make_node(:TypeName, name: val[1]) }
-
   enum_value_definition:
     enum_name directives_list_opt { return make_node(:EnumValueDefinition, name: val[0], directives: val[1], description: get_description(val[0])) }
 
@@ -306,7 +302,17 @@ rule
 
   implements_opt:
       /* none */ { return [] }
-    | IMPLEMENTS name_list { return val[1] }
+    | IMPLEMENTS AMP interfaces_list { return val[2] }
+    | IMPLEMENTS interfaces_list { return val[1] }
+    | IMPLEMENTS legacy_interfaces_list { return val[1] }
+
+  interfaces_list:
+      name                     { return [make_node(:TypeName, name: val[0])] }
+    | interfaces_list AMP name { val[0] << make_node(:TypeName, name: val[2]) }
+
+  legacy_interfaces_list:
+      name                        { return [make_node(:TypeName, name: val[0])] }
+    | legacy_interfaces_list name { val[0] << make_node(:TypeName, name: val[1]) }
 
   input_value_definition:
       name COLON type default_value_opt directives_list_opt {

data/lib/graphql/language/printer.rb

@@ -154,7 +154,7 @@ module GraphQL
       def print_object_type_definition(object_type)
         out = print_description(object_type)
         out << "type #{object_type.name}"
-        out << " implements " << object_type.interfaces.map(&:name).join(", ") unless object_type.interfaces.empty?
+        out << " implements " << object_type.interfaces.map(&:name).join(" & ") unless object_type.interfaces.empty?
         out << print_directives(object_type.directives)
         out << print_field_definitions(object_type.fields)
       end
@@ -339,7 +339,7 @@ module GraphQL
         when Hash
           "{#{node.map { |k, v| "#{k}: #{print_node(v)}" }.join(", ")}}".dup
         else
-          raise TypeError
+          GraphQL::Language.serialize(node.to_s)
         end
       end
 

data/lib/graphql/object_type.rb

@@ -102,11 +102,6 @@ module GraphQL
       dirty_ifaces.concat(interfaces)
     end
 
-    def name=(name)
-      GraphQL::NameValidator.validate!(name)
-      @name = name
-    end
-
     protected
 
     attr_reader :dirty_interfaces, :dirty_inherited_interfaces

data/lib/graphql/relay/relation_connection.rb

@@ -27,7 +27,7 @@ module GraphQL
         if first
           paged_nodes.length >= first && sliced_nodes_count > first
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
-          sliced_nodes_count > last
+          sliced_nodes_count >= last
         else
           false
         end

data/lib/graphql/schema.rb

@@ -64,6 +64,7 @@ module GraphQL
   #   end
   #
   class Schema
+    extend GraphQL::Schema::Member::AcceptsDefinition
     include GraphQL::Define::InstanceDefinable
     accepts_definitions \
       :query, :mutation, :subscription,
@@ -197,6 +198,9 @@ module GraphQL
       rescue_middleware.remove_handler(*args, &block)
     end
 
+    # For forwards-compatibility with Schema classes
+    alias :graphql_definition :itself
+
     # Validate a query string according to this schema.
     # @param string_or_document [String, GraphQL::Language::Nodes::Document]
     # @return [Array<GraphQL::StaticValidation::Message>]
@@ -681,6 +685,7 @@ module GraphQL
         schema_defn.id_from_object = method(:id_from_object)
         schema_defn.type_error = method(:type_error)
         schema_defn.context_class = context_class
+        schema_defn.cursor_encoder = cursor_encoder
         schema_defn.tracers.concat(defined_tracers)
         schema_defn.query_analyzers.concat(defined_query_analyzers)
         schema_defn.multiplex_analyzers.concat(defined_multiplex_analyzers)
@@ -749,6 +754,13 @@ module GraphQL
         end
       end
 
+      def cursor_encoder(new_encoder = nil)
+        if new_encoder
+          @cursor_encoder = new_encoder
+        end
+        @cursor_encoder || Base64Encoder
+      end
+
       def default_max_page_size(new_default_max_page_size = nil)
         if new_default_max_page_size
           @default_max_page_size = new_default_max_page_size
@@ -773,9 +785,9 @@ module GraphQL
         end
       end
 
-      def orphan_types(new_orphan_types = nil)
-        if new_orphan_types
-          @orphan_types = new_orphan_types
+      def orphan_types(*new_orphan_types)
+        if new_orphan_types.any?
+          @orphan_types = new_orphan_types.flatten
         else
           @orphan_types || []
         end

data/lib/graphql/schema/argument.rb

@@ -3,11 +3,15 @@ module GraphQL
   class Schema
     class Argument
       include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::AcceptsDefinition
 
       NO_DEFAULT = :__no_default__
 
       attr_reader :name
 
+      # @return [GraphQL::Schema::Field, Class] The field or input object this argument belongs to
+      attr_reader :owner
+
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
@@ -15,13 +19,26 @@ module GraphQL
       # @param description [String]
       # @param default_value [Object]
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
-      def initialize(arg_name, type_expr, desc = nil, required:, description: nil, default_value: NO_DEFAULT, camelize: true)
+      def initialize(arg_name, type_expr, desc = nil, required:, description: nil, default_value: NO_DEFAULT, camelize: true, owner:, &definition_block)
         @name = arg_name.to_s
         @type_expr = type_expr
         @description = desc || description
         @null = !required
         @default_value = default_value
         @camelize = camelize
+        @owner = owner
+
+        if definition_block
+          instance_eval(&definition_block)
+        end
+      end
+
+      def description(text = nil)
+        if text
+          @description = text
+        else
+          @description
+        end
       end
 
       def to_graphql

data/lib/graphql/schema/enum.rb

@@ -20,6 +20,8 @@ module GraphQL
   #   end
   class Schema
     class Enum < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
       class << self
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
@@ -28,8 +30,9 @@ module GraphQL
         # @param deprecation_reason [String] if this object is deprecated, include a message here
         # @return [void]
         # @see {Schema::EnumValue} which handles these inputs by default
-        def value(*args, &block)
-          value = enum_value_class.new(*args, &block)
+        def value(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          value = enum_value_class.new(*args, **kwargs, &block)
           own_values[value.graphql_name] = value
           nil
         end

data/lib/graphql/schema/enum_value.rb

@@ -26,13 +26,20 @@ module GraphQL
     #     enum_value_class CustomEnumValue
     #   end
     class EnumValue < GraphQL::Schema::Member
+      include GraphQL::Schema::Member::AcceptsDefinition
+
       attr_reader :graphql_name
 
-      def initialize(graphql_name, desc = nil, description: nil, value: nil, deprecation_reason: nil, &block)
+      # @return [Class] The enum type that owns this value
+      attr_reader :owner
+
+      def initialize(graphql_name, desc = nil, owner:, description: nil, value: nil, deprecation_reason: nil, &block)
         @graphql_name = graphql_name.to_s
         @description = desc || description
         @value = value || @graphql_name
         @deprecation_reason = deprecation_reason
+        @owner = owner
+
         if block_given?
           instance_eval(&block)
         end

data/lib/graphql/schema/field.rb

@@ -6,6 +6,7 @@ module GraphQL
   class Schema
     class Field
       include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::AcceptsDefinition
 
       # @return [String]
       attr_reader :name
@@ -19,9 +20,13 @@ module GraphQL
       # @return [Symbol]
       attr_reader :method
 
+      # @return [Class] The type that this field belongs to
+      attr_reader :owner
+
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
       # @param return_type_expr [Class, GraphQL::BaseType, Array] The return type of this field
       # @param desc [String] Field description
+      # @param owner [Class] The type that this field belongs to
       # @param null [Boolean] `true` if this field may return `null`, `false` if it is never `null`
       # @param description [String] Field description
       # @param deprecation_reason [String] If present, the field is marked "deprecated" with this message
@@ -35,7 +40,7 @@ module GraphQL
       # @param function [GraphQL::Function] **deprecated** for compatibility with <1.8.0
       # @param camelize [Boolean] If true, the field name will be camelized when building the schema
       # @param complexity [Numeric] When provided, set the complexity for this field
-      def initialize(name, return_type_expr = nil, desc = nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], &definition_block)
+      def initialize(name, return_type_expr = nil, desc = nil, owner:, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], &definition_block)
         if (field || function) && desc.nil? && return_type_expr.is_a?(String)
           # The return type should be copied from `field` or `function`, and the second positional argument is the description
           desc = return_type_expr
@@ -75,6 +80,7 @@ module GraphQL
         @extras = extras
         @arguments = {}
         @camelize = camelize
+        @owner = owner
 
         if definition_block
           instance_eval(&definition_block)
@@ -82,8 +88,9 @@ module GraphQL
       end
 
       # This is the `argument(...)` DSL for class-based field definitons
-      def argument(*args)
-        arg_defn = self.class.argument_class.new(*args)
+      def argument(*args, **kwargs, &block)
+        kwargs[:owner] = self
+        arg_defn = self.class.argument_class.new(*args, **kwargs, &block)
         arguments[arg_defn.name] = arg_defn
       end
 

data/lib/graphql/schema/input_object.rb

@@ -2,6 +2,7 @@
 module GraphQL
   class Schema
     class InputObject < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Delegate
 
       def initialize(values, context:, defaults_used:)
@@ -23,8 +24,9 @@ module GraphQL
         # @return [Class<GraphQL::Arguments>]
         attr_accessor :arguments_class
 
-        def argument(*args)
-          argument = GraphQL::Schema::Argument.new(*args)
+        def argument(*args, **kwargs)
+          kwargs[:owner] = self
+          argument = GraphQL::Schema::Argument.new(*args, **kwargs)
           arg_name = argument.graphql_definition.name
           own_arguments[arg_name] = argument
           # Add a method access

data/lib/graphql/schema/interface.rb

@@ -3,6 +3,7 @@ module GraphQL
   class Schema
     class Interface < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Member::AcceptsDefinition
       field_class GraphQL::Schema::Field
 
       class << self
@@ -15,14 +16,28 @@ module GraphQL
           end
         end
 
+        def orphan_types(*types)
+          if types.any?
+            @orphan_types = types
+          else
+            all_orphan_types = @orphan_types || []
+            all_orphan_types += super if defined?(super)
+            all_orphan_types.uniq
+          end
+        end
+
         def to_graphql
           type_defn = GraphQL::InterfaceType.new
           type_defn.name = graphql_name
           type_defn.description = description
+          type_defn.orphan_types = orphan_types
           fields.each do |field_name, field_inst|
             field_defn = field_inst.graphql_definition
             type_defn.fields[field_defn.name] = field_defn
           end
+          if respond_to?(:resolve_type)
+            type_defn.resolve_type = method(:resolve_type)
+          end
           type_defn
         end
       end

data/lib/graphql/schema/member.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'graphql/schema/member/accepts_definition'
 require "graphql/relay/type_extensions"
 
 module GraphQL
@@ -27,7 +28,7 @@ module GraphQL
       # These constants are interpreted as GraphQL types
       #
       # @example
-      #   field :isDraft, Boolean, null: false
+      #   field :is_draft, Boolean, null: false
       #   field :id, ID, null: false
       #   field :score, Int, null: false
       module GraphQLTypeNames

data/lib/graphql/schema/member/accepts_definition.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Support for legacy `accepts_definitions` functions.
+      #
+      # Keep the legacy handler hooked up. Class-based types and fields
+      # will call those legacy handlers during their `.to_graphql`
+      # methods.
+      #
+      # This can help out while transitioning from one to the other.
+      # Eventually, `GraphQL::{X}Type` objects will be removed entirely,
+      # But this can help during the transition.
+      #
+      # @example Applying a function to base object class
+      #   # Here's the legacy-style config, which we're calling back to:
+      #   GraphQL::ObjectType.accepts_definition({
+      #     permission_level: ->(defn, value) { defn.metadata[:permission_level] = value }
+      #   })
+      #
+      #   class BaseObject < GraphQL::Schema::Object
+      #     # Setup a named pass-through to the legacy config functions
+      #     accepts_definition :permission_level
+      #   end
+      #
+      #   class Account < BaseObject
+      #     # This value will be passed to the legacy handler:
+      #     permission_level 1
+      #   end
+      #
+      #   # The class gets a reader method which returns the args,
+      #   # only marginally useful.
+      #   Account.permission_level # => [1]
+      #
+      #   # The legacy handler is called, as before:
+      #   Account.graphql_definition.metadata[:permission_level] # => 1
+      module AcceptsDefinition
+        def self.included(child)
+          child.extend(ClassMethods)
+          child.prepend(ToGraphQLExtension)
+          child.prepend(InitializeExtension)
+        end
+
+        def self.extended(child)
+          child.extend(ClassMethods)
+          # I tried to use `super`, but super isn't quite right
+          # since the method is defined in the same class itself,
+          # not the superclass
+          child.class_eval do
+            class << self
+              prepend(ToGraphQLExtension)
+            end
+          end
+        end
+
+        module ClassMethods
+          def accepts_definition(name)
+            @accepts_definition_methods ||= []
+            @accepts_definition_methods << name
+            ivar_name = "@#{name}_args"
+            define_singleton_method(name) do |*args|
+              if args.any?
+                instance_variable_set(ivar_name, args)
+              end
+              instance_variable_get(ivar_name)
+            end
+
+            define_method(name) do |*args|
+              if args.any?
+                instance_variable_set(ivar_name, args)
+              end
+              instance_variable_get(ivar_name)
+            end
+          end
+
+          def accepts_definition_methods
+            @accepts_definition_methods ||= []
+            sc = self.is_a?(Class) ? superclass : self.class.superclass
+            @accepts_definition_methods + (sc.respond_to?(:accepts_definition_methods) ? sc.accepts_definition_methods : [])
+          end
+        end
+
+        module ToGraphQLExtension
+          def to_graphql
+            defn = super
+            accepts_definition_methods.each do |method_name|
+              value = instance_variable_get("@#{method_name}_args")
+              if !value.nil?
+                defn = defn.redefine { public_send(method_name, *value) }
+              end
+            end
+            defn
+          end
+        end
+
+        module InitializeExtension
+          def initialize(*args, **kwargs, &block)
+            self.class.accepts_definition_methods.each do |method_name|
+              if kwargs.key?(method_name)
+                value = kwargs.delete(method_name)
+                if !value.is_a?(Array)
+                  value = [value]
+                end
+                instance_variable_set("@#{method_name}_args", value)
+              end
+            end
+            super(*args, **kwargs, &block)
+          end
+
+          def accepts_definition_methods
+            self.class.accepts_definition_methods
+          end
+        end
+      end
+    end
+  end
+end