graphql 1.9.0.pre1 → 1.9.0.pre2

data/lib/graphql/schema/directive/feature.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      # An example directive to show how you might interact with the runtime.
+      #
+      # This directive might be used along with a server-side feature flag system like Flipper.
+      #
+      # With that system, you could use this directive to exclude parts of a query
+      # if the current viewer doesn't have certain flags enabled.
+      # (So, this flag would be for internal clients, like your iOS app, not third-party API clients.)
+      #
+      # To use it, you have to implement `.enabled?`, for example:
+      #
+      # @example Implementing the Feature directive
+      #   # app/graphql/directives/feature.rb
+      #   class Directives::Feature < GraphQL::Schema::Directive::Feature
+      #     def self.enabled?(flag_name, _obj, context)
+      #       # Translate some GraphQL data for Ruby:
+      #       flag_key = flag_name.underscore
+      #       current_user = context[:viewer]
+      #       # Check the feature flag however your app does it:
+      #       MyFeatureFlags.enabled?(current_user, flag_key)
+      #     end
+      #   end
+      #
+      # @example Flagging a part of the query
+      #   viewer {
+      #     # This field only runs if `.enabled?("recommendationEngine", obj, context)`
+      #     # returns true. Otherwise, it's treated as if it didn't exist.
+      #     recommendations @feature(flag: "recommendationEngine") {
+      #       name
+      #       rating
+      #     }
+      #   }
+      class Feature < Schema::Directive
+        description "Directs the executor to run this only if a certain server-side feature is enabled."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+          GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+          GraphQL::Schema::Directive::INLINE_FRAGMENT
+        )
+
+        argument :flag, String, required: true,
+          description: "The name of the feature to check before continuing"
+
+        # Implement the Directive API
+        def self.include?(object, arguments, context)
+          flag_name = arguments[:flag]
+          self.enabled?(flag_name, object, context)
+        end
+
+        # Override this method in your app's subclass of this directive.
+        #
+        # @param flag_name [String] The client-provided string of a feature to check
+        # @param object [GraphQL::Schema::Objct] The currently-evaluated GraphQL object instance
+        # @param context [GraphQL::Query::Context]
+        # @return [Boolean] If truthy, execution will continue
+        def self.enabled?(flag_name, object, context)
+          raise NotImplementedError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive/include.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class Include < GraphQL::Schema::Directive
+        description "Directs the executor to include this field or fragment only when the `if` argument is true."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+          GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+          GraphQL::Schema::Directive::INLINE_FRAGMENT
+        )
+
+        argument :if, Boolean, required: true,
+          description: "Included when true."
+
+        default_directive true
+
+        def self.include?(obj, args, ctx)
+          !!args[:if]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive/skip.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class Skip < Schema::Directive
+        description "Directs the executor to skip this field or fragment when the `if` argument is true."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+          GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+          GraphQL::Schema::Directive::INLINE_FRAGMENT
+        )
+
+        argument :if, Boolean, required: true,
+          description: "Skipped when true."
+
+        default_directive true
+
+        def self.include?(obj, args, ctx)
+          !args[:if]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive/transform.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      # An example directive to show how you might interact with the runtime.
+      #
+      # This directive takes the return value of the tagged part of the query,
+      # and if the named transform is whitelisted and applies to the return value,
+      # it's applied by calling a method with that name.
+      #
+      # @example Installing the directive
+      #   class MySchema < GraphQL::Schema
+      #     directive(GraphQL::Schema::Directive::Transform)
+      #   end
+      #
+      # @example Transforming strings
+      #   viewer {
+      #     username @transform(by: "upcase")
+      #   }
+      class Transform < Schema::Directive
+        description "Directs the executor to run named transform on the return value."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+        )
+
+        argument :by, String, required: true,
+          description: "The name of the transform to run if applicable"
+
+        TRANSFORMS = [
+          "upcase",
+          "downcase",
+          # ??
+        ]
+        # Implement the Directive API
+        def self.resolve(object, arguments, context)
+          path = context.namespace(:interpreter)[:current_path]
+          return_value = yield
+          transform_name = arguments[:by]
+          if TRANSFORMS.include?(transform_name) && return_value.respond_to?(transform_name)
+            return_value = return_value.public_send(transform_name)
+            context.namespace(:interpreter)[:runtime].write_in_response(path, return_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/enum_value.rb

@@ -40,7 +40,7 @@ module GraphQL
       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
+        @value = value.nil? ? @graphql_name : value
         @deprecation_reason = deprecation_reason
         @owner = owner
 
@@ -57,7 +57,7 @@ module GraphQL
       end
 
       def value(new_val = nil)
-        if new_val
+        unless new_val.nil?
           @value = new_val
         end
         @value

data/lib/graphql/schema/field.rb

@@ -20,15 +20,21 @@ module GraphQL
       # @return [String, nil] If present, the field is marked as deprecated with this documentation
       attr_accessor :deprecation_reason
 
-      # @return [Symbol] Method or hash key to look up
+      # @return [Symbol] Method or hash key on the underlying object to look up
       attr_reader :method_sym
 
-      # @return [String] Method or hash key to look up
+      # @return [String] Method or hash key on the underlying object to look up
       attr_reader :method_str
 
+      # @return [Symbol] The method on the type to look up
+      attr_reader :resolver_method
+
       # @return [Class] The type that this field belongs to
       attr_reader :owner
 
+      # @return [Symobol] the original name of the field, passed in by the user
+      attr_reader :original_name
+
       # @return [Class, nil] The {Schema::Resolver} this field was derived from, if there is one
       def resolver
         @resolver_class
@@ -123,8 +129,9 @@ module GraphQL
       # @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
-      # @param method [Symbol] The method to call to resolve this field (defaults to `name`)
-      # @param hash_key [Object] The hash key to lookup to resolve this field (defaults to `name` or `name.to_s`)
+      # @param method [Symbol] The method to call on the underlying object to resolve this field (defaults to `name`)
+      # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+      # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param max_page_size [Integer] For connections, the maximum number of items to return from this field
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
@@ -139,7 +146,7 @@ module GraphQL
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
       # @param extensions [Array<Class>] Named extensions to apply to this field (see also {#extension})
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, scope: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, trace: nil, complexity: 1, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, arguments: {}, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, arguments: {}, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -154,6 +161,8 @@ module GraphQL
         if (field || function || resolve) && extras.any?
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
         end
+        @original_name = name
+        @underscored_name = Member::BuildType.underscore(name.to_s)
         @name = camelize ? Member::BuildType.camelize(name.to_s) : name.to_s
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
@@ -164,15 +173,28 @@ module GraphQL
         @function = function
         @resolve = resolve
         @deprecation_reason = deprecation_reason
+
         if method && hash_key
           raise ArgumentError, "Provide `method:` _or_ `hash_key:`, not both. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}`)"
         end
 
+        if resolver_method
+          if method
+            raise ArgumentError, "Provide `method:` _or_ `resolver_method:`, not both. (called with: `method: #{method.inspect}, resolver_method: #{resolver_method.inspect}`)"
+          end
+
+          if hash_key
+            raise ArgumentError, "Provide `hash_key:` _or_ `resolver_method:`, not both. (called with: `hash_key: #{hash_key.inspect}, resolver_method: #{resolver_method.inspect}`)"
+          end
+        end
+
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
-        method_name = method || hash_key || Member::BuildType.underscore(name.to_s)
+        method_name = method || hash_key || @underscored_name
+        resolver_method ||= @underscored_name
 
         @method_str = method_name.to_s
         @method_sym = method_name.to_sym
+        @resolver_method = resolver_method
         @complexity = complexity
         @return_type_expr = type
         @return_type_null = null
@@ -396,7 +418,17 @@ MSG
           true
         end
 
-        self_auth && arguments.each_value.all? { |a| a.authorized?(object, context) }
+        if self_auth
+          # Faster than `.any?`
+          arguments.each_value do |arg|
+            if !arg.authorized?(object, context)
+              return false
+            end
+          end
+          true
+        else
+          false
+        end
       end
 
       # Implement {GraphQL::Field}'s resolve API.
@@ -407,7 +439,9 @@ MSG
         ctx.schema.after_lazy(obj) do |after_obj|
           # First, apply auth ...
           query_ctx = ctx.query.context
-          inner_obj = after_obj.object
+          # Some legacy fields can have `nil` here, not exactly sure why.
+          # @see https://github.com/rmosolgo/graphql-ruby/issues/1990 before removing
+          inner_obj = after_obj && after_obj.object
           if authorized?(inner_obj, query_ctx)
             # Then if it passed, resolve the field
             if @resolve_proc
@@ -417,7 +451,8 @@ MSG
               public_send_field(after_obj, args, ctx)
             end
           else
-            nil
+            err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
+            query_ctx.schema.unauthorized_field(err)
           end
         end
       end
@@ -448,13 +483,20 @@ MSG
                 extended_obj
               end
 
-              # Call the method with kwargs, if there are any
-              if extended_args.any?
-                field_receiver.public_send(method_sym, extended_args)
+              if field_receiver.respond_to?(@resolver_method)
+                # Call the method with kwargs, if there are any
+                if extended_args.any?
+                  field_receiver.public_send(@resolver_method, **extended_args)
+                else
+                  field_receiver.public_send(@resolver_method)
+                end
               else
-                field_receiver.public_send(method_sym)
+                resolve_field_method(field_receiver, extended_args, ctx)
               end
             end
+          else
+            err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+            ctx.schema.unauthorized_field(err)
           end
         rescue GraphQL::UnauthorizedError => err
           ctx.schema.unauthorized_object(err)
@@ -491,7 +533,7 @@ MSG
           raise <<-ERR
         Failed to implement #{@owner.graphql_name}.#{@name}, tried:
 
-        - `#{obj.class}##{@method_sym}`, which did not exist
+        - `#{obj.class}##{@resolver_method}`, which did not exist
         - `#{obj.object.class}##{@method_sym}`, which did not exist
         - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
 
@@ -543,10 +585,14 @@ MSG
             extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx)
           end
 
-          if extended_args.any?
-            extended_obj.public_send(@method_sym, **extended_args)
+          if extended_obj.respond_to?(@resolver_method)
+            if extended_args.any?
+              extended_obj.public_send(@resolver_method, **extended_args)
+            else
+              extended_obj.public_send(@resolver_method)
+            end
           else
-            extended_obj.public_send(@method_sym)
+            resolve_field_method(extended_obj, extended_args, query_ctx)
           end
         end
       end

data/lib/graphql/schema/input_object.rb

@@ -5,6 +5,7 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
+      include GraphQL::Dig
 
       def initialize(values = nil, ruby_kwargs: nil, context:, defaults_used:)
         @context = context

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

@@ -83,9 +83,11 @@ module GraphQL
         # The default name is the Ruby constant name,
         # without any namespaces and with any `-Type` suffix removed
         def default_graphql_name
-          raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
+          @default_graphql_name ||= begin
+            raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
 
-          name.split("::").last.sub(/Type\Z/, "")
+            name.split("::").last.sub(/Type\Z/, "")
+          end
         end
 
         def visible?(context)

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

@@ -33,7 +33,7 @@ module GraphQL
               null = false
               parse_type(type_expr[0..-2], null: true)
             else
-              maybe_type = Object.const_get(type_expr)
+              maybe_type = constantize(type_expr)
               case maybe_type
               when GraphQL::BaseType
                 maybe_type
@@ -125,6 +125,38 @@ module GraphQL
           camelized
         end
 
+        # Resolves constant from string (based on Rails `ActiveSupport::Inflector.constantize`)
+        def constantize(string)
+          names = string.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(string) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+              next candidate if constant.const_defined?(name, false)
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+
+              # Owner is in Object, so raise.
+              constant.const_get(name, false)
+            end
+          end
+        end
+
         def underscore(string)
           string
             .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder

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

@@ -4,47 +4,6 @@ module GraphQL
     class Member
       # Shared code for Object and Interface
       module HasFields
-        class << self
-          # When this module is added to a class,
-          # add a place for that class's default behaviors
-          def self.extended(child_class)
-            add_default_resolve_module(child_class)
-            super
-          end
-
-          # Create a module which will have instance methods for implementing fields.
-          # These will be `super` methods for fields in interfaces, objects and mutations.
-          # Use an instance variable on the class instead of a constant
-          # so that module namespaces won't be an issue. (If we used constants,
-          # `child_class::DefaultResolve` might find a constant from an included module.)
-          def add_default_resolve_module(child_class)
-            if child_class.instance_variable_get(:@_default_resolve)
-              # This can happen when an object implements an interface,
-              # since that interface has the `included` hook above.
-              return
-            end
-
-            default_resolve_module = Module.new
-            child_class.instance_variable_set(:@_default_resolve, default_resolve_module)
-            child_class.include(default_resolve_module)
-          end
-        end
-
-        # When this is included into interfaces,
-        # add a place for default field behaviors
-        def included(child_class)
-          HasFields.add_default_resolve_module(child_class)
-          # Also, prepare a place for default field implementations
-          super
-        end
-
-        # When a subclass of objects are created,
-        # add a place for that subclass's default field behaviors
-        def inherited(child_class)
-          HasFields.add_default_resolve_module(child_class)
-          super
-        end
-
         # Add a field to this object or interface with the given definition
         # @see {GraphQL::Schema::Field#initialize} for method signature
         # @return [void]
@@ -67,24 +26,23 @@ module GraphQL
         end
 
         def get_field(field_name)
-          for ancestor in ancestors
-            if ancestor.respond_to?(:own_fields) && f = ancestor.own_fields[field_name]
-              return f
+          if (f = own_fields[field_name])
+            f
+          else
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_fields) && f = ancestor.own_fields[field_name]
+                return f
+              end
             end
+            nil
           end
-          nil
         end
 
         # Register this field with the class, overriding a previous one if needed.
-        # Also, add a parent method for resolving this field.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
         def add_field(field_defn)
           own_fields[field_defn.name] = field_defn
-          if !method_defined?(field_defn.method_sym)
-            # Only add the super method if there isn't one already.
-            add_super_method(field_defn.name.inspect, field_defn.method_sym)
-          end
           nil
         end
 
@@ -114,29 +72,6 @@ module GraphQL
         def own_fields
           @own_fields ||= {}
         end
-
-        private
-        # Find the magic module for holding super methods,
-        # and add a field named `method_name` for implementing the field
-        # called `field_name`.
-        # It will be the `super` method if the method is overwritten in the class definition.
-        def add_super_method(field_key, method_name)
-          default_resolve_module = @_default_resolve
-          if default_resolve_module.nil?
-            # This should have been set up in one of the inherited or included hooks above,
-            # if it wasn't, it's because those hooks weren't called because `super` wasn't present.
-            raise <<-ERR
-Uh oh! #{self} doesn't have a default resolve module. This probably means that an `inherited` hook didn't call super.
-Check `inherited` on #{self}'s superclasses.
-ERR
-          end
-          default_resolve_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method_name}(**args)
-              field_inst = self.class.get_field(#{field_key}) || raise(%|Failed to find field #{field_key} for \#{self.class} among \#{self.class.fields.keys}|)
-              field_inst.resolve_field_method(self, args, context)
-            end
-          RUBY
-        end
       end
     end
   end