graphql 1.12.12 → 2.2.14

data/lib/graphql/schema/argument.rb

@@ -2,20 +2,12 @@
 module GraphQL
   class Schema
     class Argument
-      if !String.method_defined?(:-@)
-        using GraphQL::StringDedupBackport
-      end
-
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
       include GraphQL::Schema::Member::HasValidators
-      include GraphQL::Schema::FindInheritedValue::EmptyObjects
-
-      NO_DEFAULT = :__no_default__
+      include GraphQL::EmptyObjects
 
       # @return [String] the GraphQL name for this argument, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -24,8 +16,14 @@ module GraphQL
       # @return [GraphQL::Schema::Field, Class] The field or input object this argument belongs to
       attr_reader :owner
 
-      # @return [Symbol] A method to call to transform this value before sending it to field resolution method
-      attr_reader :prepare
+      # @param new_prepare [Method, Proc]
+      # @return [Symbol] A method or proc to call to transform this value before sending it to field resolution method
+      def prepare(new_prepare = NOT_CONFIGURED)
+        if new_prepare != NOT_CONFIGURED
+          @prepare = new_prepare
+        end
+        @prepare
+      end
 
       # @return [Symbol] This argument's name in Ruby keyword arguments
       attr_reader :keyword
@@ -41,24 +39,31 @@ module GraphQL
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
-      # @param required [Boolean] if true, this argument is non-null; if false, this argument is nullable
+      # @param required [Boolean, :nullable] if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
       # @param description [String]
       # @param default_value [Object]
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       # @param from_resolver [Boolean] if true, a Resolver class defined this argument
-      # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
       # @param directives [Hash{Class => Hash}]
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, &definition_block)
+      # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
-        @null = !required
+        @null = required != true
         @default_value = default_value
+        if replace_null_with_default
+          if !default_value?
+            raise ArgumentError, "`replace_null_with_default: true` requires a default value, please provide one with `default_value: ...`"
+          end
+          @replace_null_with_default = true
+        end
+
         @owner = owner
         @as = as
         @loads = loads
@@ -66,7 +71,6 @@ module GraphQL
         @prepare = prepare
         @ast_node = ast_node
         @from_resolver = from_resolver
-        @method_access = method_access
         self.deprecation_reason = deprecation_reason
 
         if directives
@@ -75,7 +79,13 @@ module GraphQL
           end
         end
 
-        self.validates(validates)
+        if validates && !validates.empty?
+          self.validates(validates)
+        end
+
+        if required == :nullable
+          self.owner.validates(required: { argument: arg_name })
+        end
 
         if definition_block
           if definition_block.arity == 1
@@ -86,12 +96,26 @@ module GraphQL
         end
       end
 
+      def inspect
+        "#<#{self.class} #{path}: #{type.to_type_signature}#{description ? " @description=#{description.inspect}" : ""}>"
+      end
+
+      # @param default_value [Object] The value to use when the client doesn't provide one
       # @return [Object] the value used when the client doesn't provide a value for this argument
-      attr_reader :default_value
+      def default_value(new_default_value = NOT_CONFIGURED)
+        if new_default_value != NOT_CONFIGURED
+          @default_value = new_default_value
+        end
+        @default_value
+      end
 
       # @return [Boolean] True if this argument has a default value
       def default_value?
-        @default_value != NO_DEFAULT
+        @default_value != NOT_CONFIGURED
+      end
+
+      def replace_null_with_default?
+        @replace_null_with_default
       end
 
       attr_writer :description
@@ -123,10 +147,6 @@ module GraphQL
         true
       end
 
-      def accessible?(context)
-        true
-      end
-
       def authorized?(obj, value, ctx)
         authorized_as_type?(obj, value, ctx, as_type: type)
       end
@@ -147,38 +167,13 @@ module GraphQL
             end
           end
         elsif as_type.kind.input_object?
-          as_type.arguments.each do |_name, input_obj_arg|
-            input_obj_arg = input_obj_arg.type_class
-            # TODO: this skips input objects whose values were alread replaced with application objects.
-            # See: https://github.com/rmosolgo/graphql-ruby/issues/2633
-            if value.respond_to?(:key?) && value.key?(input_obj_arg.keyword) && !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
-              return false
-            end
-          end
+          return as_type.authorized?(obj, value, ctx)
         end
         # None of the early-return conditions were activated,
         # so this is authorized.
         true
       end
 
-      def to_graphql
-        argument = GraphQL::Argument.new
-        argument.name = @name
-        argument.type = -> { type }
-        argument.description = @description
-        argument.metadata[:type_class] = self
-        argument.as = @as
-        argument.ast_node = ast_node
-        argument.method_access = @method_access
-        if NO_DEFAULT != @default_value
-          argument.default_value = @default_value
-        end
-        if self.deprecation_reason
-          argument.deprecation_reason = self.deprecation_reason
-        end
-        argument
-      end
-
       def type=(new_type)
         validate_input_type(new_type)
         # This isn't true for LateBoundTypes, but we can assume those will
@@ -203,8 +198,8 @@ module GraphQL
 
       def statically_coercible?
         return @statically_coercible if defined?(@statically_coercible)
-
-        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+        requires_parent_object = @prepare.is_a?(String) || @prepare.is_a?(Symbol) || @own_validators
+        @statically_coercible = !requires_parent_object
       end
 
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
@@ -226,8 +221,13 @@ module GraphQL
             #
             # This will have to be called later, when the runtime object _is_ available.
             value
-          else
+          elsif obj.respond_to?(@prepare)
             obj.public_send(@prepare, value)
+          elsif owner.respond_to?(@prepare)
+            owner.public_send(@prepare, value, context || obj.context)
+          else
+            raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}. "\
+              "Could not find prepare method #{@prepare} on #{obj.class} or #{owner}."
           end
         elsif @prepare.respond_to?(:call)
           @prepare.call(value, context || obj.context)
@@ -255,50 +255,104 @@ module GraphQL
           return
         end
 
+        if value.nil? && replace_null_with_default?
+          value = default_value
+          default_used = true
+        end
+
         loaded_value = nil
-        coerced_value = context.schema.error_handler.with_error_handling(context) do
+        coerced_value = begin
           type.coerce_input(value, context)
+        rescue StandardError => err
+          context.schema.handle_or_reraise(context, err)
         end
 
-        # TODO this should probably be inside after_lazy
-        if loads && !from_resolver?
-          loaded_value = if type.list?
-            loaded_values = coerced_value.map { |val| owner.load_application_object(self, loads, val, context) }
-            context.schema.after_any_lazies(loaded_values) { |result| result }
-          else
-            context.query.with_error_handling do
-              owner.load_application_object(self, loads, coerced_value, context)
+        # If this isn't lazy, then the block returns eagerly and assigns the result here
+        # If it _is_ lazy, then we write the lazy to the hash, then update it later
+        argument_values[arg_key] = context.query.after_lazy(coerced_value) do |resolved_coerced_value|
+          owner.validate_directive_argument(self, resolved_coerced_value)
+          prepared_value = begin
+            prepare_value(parent_object, resolved_coerced_value, context: context)
+          rescue StandardError => err
+            context.schema.handle_or_reraise(context, err)
+          end
+
+          if loads && !from_resolver?
+            loaded_value = begin
+              load_and_authorize_value(owner, prepared_value, context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
             end
           end
-        end
 
-        coerced_value = if loaded_value
-          loaded_value
-        else
-          coerced_value
+          maybe_loaded_value = loaded_value || prepared_value
+          context.query.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
+            # TODO code smell to access such a deeply-nested constant in a distant module
+            argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+              value: resolved_loaded_value,
+              definition: self,
+              default_used: default_used,
+            )
+          end
         end
+      end
 
-        # If this isn't lazy, then the block returns eagerly and assigns the result here
-        # If it _is_ lazy, then we write the lazy to the hash, then update it later
-        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |coerced_value|
-          owner.validate_directive_argument(self, coerced_value)
-          prepared_value = context.schema.error_handler.with_error_handling(context) do
-            prepare_value(parent_object, coerced_value, context: context)
+      def load_and_authorize_value(load_method_owner, coerced_value, context)
+        if coerced_value.nil?
+          return nil
+        end
+        arg_load_method = "load_#{keyword}"
+        if load_method_owner.respond_to?(arg_load_method)
+          custom_loaded_value = if load_method_owner.is_a?(Class)
+            load_method_owner.public_send(arg_load_method, coerced_value, context)
+          else
+            load_method_owner.public_send(arg_load_method, coerced_value)
           end
-
-          # TODO code smell to access such a deeply-nested constant in a distant module
-          argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
-            value: prepared_value,
-            definition: self,
-            default_used: default_used,
-          )
+          context.query.after_lazy(custom_loaded_value) do |custom_value|
+            if loads
+              if type.list?
+                loaded_values = custom_value.each_with_index.map { |custom_val, idx|
+                  id = coerced_value[idx]
+                  load_method_owner.authorize_application_object(self, id, context, custom_val)
+                }
+                context.schema.after_any_lazies(loaded_values, &:itself)
+              else
+                load_method_owner.authorize_application_object(self, coerced_value, context, custom_loaded_value)
+              end
+            else
+              custom_value
+            end
+          end
+        elsif loads
+          if type.list?
+            loaded_values = coerced_value.map { |val| load_method_owner.load_and_authorize_application_object(self, val, context) }
+            context.schema.after_any_lazies(loaded_values, &:itself)
+          else
+            load_method_owner.load_and_authorize_application_object(self, coerced_value, context)
+          end
+        else
+          coerced_value
         end
       end
 
       # @api private
       def validate_default_value
         coerced_default_value = begin
-          type.coerce_isolated_result(default_value) unless default_value.nil?
+          # This is weird, but we should accept single-item default values for list-type arguments.
+          # If we used `coerce_isolated_input` below, it would do this for us, but it's not really
+          # the right thing here because we expect default values in application format (Ruby values)
+          # not GraphQL format (scalar values).
+          #
+          # But I don't think Schema::List#coerce_result should apply wrapping to single-item lists.
+          prepped_default_value = if default_value.nil?
+            nil
+          elsif (type.kind.list? || (type.kind.non_null? && type.of_type.list?)) && !default_value.respond_to?(:map)
+            [default_value]
+          else
+            default_value
+          end
+
+          type.coerce_isolated_result(prepped_default_value) unless prepped_default_value.nil?
         rescue GraphQL::Schema::Enum::UnresolvedValueError
           # It raises this, which is helpful at runtime, but not here...
           default_value

data/lib/graphql/schema/base_64_encoder.rb

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
-
-require 'graphql/schema/base_64_bp'
-
+require "base64"
 module GraphQL
   class Schema
     # @api private
     module Base64Encoder
       def self.encode(unencoded_text, nonce: false)
-        Base64Bp.urlsafe_encode64(unencoded_text, padding: false)
+        Base64.urlsafe_encode64(unencoded_text, padding: false)
       end
 
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
-        Base64Bp.urlsafe_decode64(encoded_text)
+        Base64.urlsafe_decode64(encoded_text)
       rescue ArgumentError
         raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end

data/lib/graphql/schema/build_from_definition.rb

@@ -3,32 +3,28 @@ require "graphql/schema/build_from_definition/resolve_map"
 
 module GraphQL
   class Schema
-    # TODO Populate `.directive(...)` from here
     module BuildFromDefinition
-      if !String.method_defined?(:-@)
-        using GraphQL::StringDedupBackport
-      end
-
       class << self
         # @see {Schema.from_definition}
-        def from_definition(definition_string, parser: GraphQL.default_parser, **kwargs)
-          from_document(parser.parse(definition_string), **kwargs)
+        def from_definition(schema_superclass, definition_string, parser: GraphQL.default_parser, **kwargs)
+          from_document(schema_superclass, parser.parse(definition_string), **kwargs)
         end
 
-        def from_definition_path(definition_path, parser: GraphQL.default_parser, **kwargs)
-          from_document(parser.parse_file(definition_path), **kwargs)
+        def from_definition_path(schema_superclass, definition_path, parser: GraphQL.default_parser, **kwargs)
+          from_document(schema_superclass, parser.parse_file(definition_path), **kwargs)
         end
 
-        def from_document(document, default_resolve:, using: {}, relay: false)
-          Builder.build(document, default_resolve: default_resolve || {}, relay: relay, using: using)
+        def from_document(schema_superclass, document, default_resolve:, using: {}, relay: false)
+          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using)
         end
       end
 
       # @api private
       module Builder
+        include GraphQL::EmptyObjects
         extend self
 
-        def build(document, default_resolve:, using: {}, relay:)
+        def build(schema_superclass, document, default_resolve:, using: {}, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
           if default_resolve.is_a?(Hash)
@@ -41,34 +37,43 @@ module GraphQL
           end
           schema_definition = schema_defns.first
           types = {}
-          directives = {}
+          directives = schema_superclass.directives.dup
           type_resolver = build_resolve_type(types, directives, ->(type_name) { types[type_name] ||= Schema::LateBoundType.new(type_name)})
           # Make a different type resolver because we need to coerce directive arguments
           # _while_ building the schema.
           # It will dig for a type if it encounters a custom type. This could be a problem if there are cycles.
           directive_type_resolver = nil
-          directive_type_resolver = build_resolve_type(GraphQL::Schema::BUILT_IN_TYPES, directives, ->(type_name) {
+          directive_type_resolver = build_resolve_type(types, directives, ->(type_name) {
             types[type_name] ||= begin
               defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
-              build_definition_from_node(defn, directive_type_resolver, default_resolve)
+              if defn
+                build_definition_from_node(defn, directive_type_resolver, default_resolve)
+              elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+                built_in_defn
+              else
+                raise "No definition for #{type_name.inspect} found in schema document or built-in types. Add a definition for it or remove it."
+              end
             end
           })
 
+          directives.merge!(GraphQL::Schema.default_directives)
           document.definitions.each do |definition|
             if definition.is_a?(GraphQL::Language::Nodes::DirectiveDefinition)
               directives[definition.name] = build_directive(definition, directive_type_resolver)
             end
           end
 
-          directives = GraphQL::Schema.default_directives.merge(directives)
-
           # In case any directives referenced built-in types for their arguments:
           replace_late_bound_types_with_built_in(types)
 
+          schema_extensions = nil
           document.definitions.each do |definition|
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
               nil # already handled
+            when GraphQL::Language::Nodes::SchemaExtension
+              schema_extensions ||= []
+              schema_extensions << definition
             else
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
@@ -95,6 +100,16 @@ module GraphQL
               raise InvalidDocumentError.new("Specified subscription type \"#{schema_definition.subscription}\" not found in document.") unless types[schema_definition.subscription]
               subscription_root_type = types[schema_definition.subscription]
             end
+
+            if schema_definition.query.nil? &&
+                schema_definition.mutation.nil? &&
+                schema_definition.subscription.nil?
+              # This schema may have been given with directives only,
+              # check for defaults:
+              query_root_type = types['Query']
+              mutation_root_type = types['Mutation']
+              subscription_root_type = types['Subscription']
+            end
           else
             query_root_type = types['Query']
             mutation_root_type = types['Mutation']
@@ -103,7 +118,9 @@ module GraphQL
 
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
-          Class.new(GraphQL::Schema) do
+          builder = self
+
+          schema_class = Class.new(schema_superclass) do
             begin
               # Add these first so that there's some chance of resolving late-bound types
               orphan_types types.values
@@ -130,6 +147,7 @@ module GraphQL
 
             if schema_definition
               ast_node(schema_definition)
+              builder.build_directives(self, schema_definition, type_resolver)
             end
 
             using.each do |plugin, options|
@@ -157,6 +175,14 @@ module GraphQL
               child_class.definition_default_resolve = self.definition_default_resolve
             end
           end
+
+          if schema_extensions
+            schema_extensions.each do |ext|
+              build_directives(schema_class, ext, type_resolver)
+            end
+          end
+
+          schema_class
         end
 
         NullResolveType = ->(type, obj, ctx) {
@@ -196,13 +222,18 @@ module GraphQL
 
         def build_directives(definition, ast_node, type_resolver)
           dirs = prepare_directives(ast_node, type_resolver)
-          dirs.each do |dir_class, options|
-            definition.directive(dir_class, **options)
+          dirs.each do |(dir_class, options)|
+            if definition.respond_to?(:schema_directive)
+              # it's a schema
+              definition.schema_directive(dir_class, **options)
+            else
+              definition.directive(dir_class, **options)
+            end
           end
         end
 
         def prepare_directives(ast_node, type_resolver)
-          dirs = {}
+          dirs = []
           ast_node.directives.each do |dir_node|
             if dir_node.name == "deprecated"
               # This is handled using `deprecation_reason`
@@ -210,10 +241,10 @@ module GraphQL
             else
               dir_class = type_resolver.call(dir_node.name)
               if dir_class.nil?
-                raise ArgumentError, "No definition for @#{dir_node.name} on #{ast_node.name} at #{ast_node.line}:#{ast_node.col}"
+                raise ArgumentError, "No definition for @#{dir_node.name} #{ast_node.respond_to?(:name) ? "on #{ast_node.name} " : ""}at #{ast_node.line}:#{ast_node.col}"
               end
               options = args_to_kwargs(dir_class, dir_node)
-              dirs[dir_class] = options
+              dirs << [dir_class, options]
             end
           end
           dirs
@@ -344,8 +375,6 @@ module GraphQL
           end
         end
 
-        NO_DEFAULT_VALUE = {}.freeze
-
         def build_arguments(type_class, arguments, type_resolver)
           builder = self
 
@@ -353,7 +382,7 @@ module GraphQL
             default_value_kwargs = if !argument_defn.default_value.nil?
               { default_value: builder.build_default_value(argument_defn.default_value) }
             else
-              NO_DEFAULT_VALUE
+              EMPTY_HASH
             end
 
             type_class.argument(
@@ -364,7 +393,6 @@ module GraphQL
               deprecation_reason: builder.build_deprecation_reason(argument_defn.directives),
               ast_node: argument_defn,
               camelize: false,
-              method_access: false,
               directives: prepare_directives(argument_defn, type_resolver),
               **default_value_kwargs
             )
@@ -376,6 +404,7 @@ module GraphQL
           Class.new(GraphQL::Schema::Directive) do
             graphql_name(directive_definition.name)
             description(directive_definition.description)
+            repeatable(directive_definition.repeatable)
             locations(*directive_definition.locations.map { |location| location.name.to_sym })
             ast_node(directive_definition)
             builder.build_arguments(self, directive_definition.arguments, type_resolver)
@@ -388,6 +417,10 @@ module GraphQL
             include GraphQL::Schema::Interface
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
+            interface_type_definition.interfaces.each do |interface_name|
+              interface_defn = type_resolver.call(interface_name)
+              implements(interface_defn)
+            end
             ast_node(interface_type_definition)
             builder.build_directives(self, interface_type_definition, type_resolver)
 
@@ -399,14 +432,12 @@ module GraphQL
           builder = self
 
           field_definitions.each do |field_definition|
-            type_name = resolve_type_name(field_definition.type)
             resolve_method_name = -"resolve_field_#{field_definition.name}"
             schema_field_defn = owner.field(
               field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
               null: true,
-              connection: type_name.end_with?("Connection"),
               connection_extension: nil,
               deprecation_reason: build_deprecation_reason(field_definition.directives),
               ast_node: field_definition,
@@ -454,15 +485,6 @@ module GraphQL
           }
           resolve_type_proc
         end
-
-        def resolve_type_name(type)
-          case type
-          when GraphQL::Language::Nodes::TypeName
-            return type.name
-          else
-            resolve_type_name(type.of_type)
-          end
-        end
       end
 
       private_constant :Builder

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

@@ -42,7 +42,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :flag, String, required: true,
+        argument :flag, String,
           description: "The name of the feature to check before continuing"
 
         # Implement the Directive API

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

@@ -35,7 +35,7 @@ module GraphQL
           GraphQL::Schema::Directive::INPUT_FIELD_DEFINITION,
         )
 
-        argument :by, [String], "Flags to check for this schema member", required: true
+        argument :by, [String], "Flags to check for this schema member"
 
         module VisibleByFlag
           def self.included(schema_class)
@@ -44,7 +44,7 @@ module GraphQL
 
           def visible?(context)
             if dir = self.directives.find { |d| d.is_a?(Flagged) }
-              relevant_flags = (f = context[:flags]) && dir.arguments[:by] & f
+              relevant_flags = (f = context[:flags]) && dir.arguments[:by] & f # rubocop:disable Development/ContextIsPassedCop -- definition-related
               relevant_flags && relevant_flags.any? && super
             else
               super

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

@@ -11,7 +11,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :if, Boolean, required: true,
+        argument :if, Boolean,
           description: "Included when true."
 
         default_directive true

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class OneOf < GraphQL::Schema::Directive
+        description "Requires that exactly one field must be supplied and that field must not be `null`."
+        locations(GraphQL::Schema::Directive::INPUT_OBJECT)
+        default_directive true
+
+        def initialize(...)
+          super
+
+          owner.extend(IsOneOf)
+        end
+
+        module IsOneOf
+          def one_of?
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :if, Boolean, required: true,
+        argument :if, Boolean,
           description: "Skipped when true."
 
         default_directive true