graphql 1.10.2 → 2.0.21

data/lib/graphql/define/assign_argument.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    # Turn argument configs into a {GraphQL::Argument}.
-    module AssignArgument
-      def self.call(target, *args, **kwargs, &block)
-        argument = GraphQL::Argument.from_dsl(*args, **kwargs, &block)
-        target.arguments[argument.name] = argument
-      end
-    end
-  end
-end

data/lib/graphql/define/assign_connection.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    module AssignConnection
-      def self.call(type_defn, *field_args, max_page_size: nil, **field_kwargs, &field_block)
-        underlying_field = GraphQL::Define::AssignObjectField.call(type_defn, *field_args, **field_kwargs, &field_block)
-        underlying_field.connection_max_page_size = max_page_size
-        underlying_field.connection = true
-        type_defn.fields[underlying_field.name] = underlying_field
-      end
-    end
-  end
-end

data/lib/graphql/define/assign_enum_value.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    # @api deprecated
-    module AssignEnumValue
-      def self.call(enum_type, name, desc = nil, deprecation_reason: nil, value: name, &block)
-        enum_value = GraphQL::EnumType::EnumValue.define(
-          name: name.to_s,
-          description: desc,
-          deprecation_reason: deprecation_reason,
-          value: value,
-          &block
-        )
-        enum_type.add_value(enum_value)
-      end
-    end
-  end
-end

data/lib/graphql/define/assign_global_id_field.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    module AssignGlobalIdField
-      def self.call(type_defn, field_name)
-        resolve = GraphQL::Relay::GlobalIdResolve.new(type: type_defn)
-        GraphQL::Define::AssignObjectField.call(type_defn, field_name, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
-      end
-    end
-  end
-end

data/lib/graphql/define/assign_mutation_function.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    module AssignMutationFunction
-      def self.call(target, function)
-        # TODO: get all this logic somewhere easier to test
-
-        if !function.type.is_a?(GraphQL::ObjectType)
-          raise "Mutation functions must return object types (not #{function.type.unwrap})"
-        end
-
-        target.return_type = function.type.redefine {
-          name(target.name + "Payload")
-          field :clientMutationId, types.String, "A unique identifier for the client performing the mutation.", property: :client_mutation_id
-        }
-
-        target.arguments = function.arguments
-        target.description = function.description
-        target.resolve = ->(o, a, c) {
-          res = function.call(o, a, c)
-          ResultProxy.new(res, a[:clientMutationId])
-        }
-      end
-
-      class ResultProxy < SimpleDelegator
-        attr_reader :client_mutation_id
-        def initialize(target, client_mutation_id)
-          @client_mutation_id = client_mutation_id
-          super(target)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/define/assign_object_field.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    # @api deprecated
-    module AssignObjectField
-      def self.call(owner_type, name, type_or_field = nil, desc = nil, function: nil, field: nil, relay_mutation_function: nil, **kwargs, &block)
-        name_s = name.to_s
-
-        # Move some positional args into keywords if they're present
-        desc && kwargs[:description] ||= desc
-        name && kwargs[:name] ||= name_s
-
-        if !type_or_field.nil? && !type_or_field.is_a?(GraphQL::Field)
-          # Maybe a string, proc or BaseType
-          kwargs[:type] = type_or_field
-        end
-
-        base_field = if type_or_field.is_a?(GraphQL::Field)
-          type_or_field.redefine(name: name_s)
-        elsif function
-          func_field = GraphQL::Function.build_field(function)
-          func_field.name = name_s
-          func_field
-        elsif field.is_a?(GraphQL::Field)
-          field.redefine(name: name_s)
-        else
-          nil
-        end
-
-        obj_field = if base_field
-          base_field.redefine(**kwargs, &block)
-        else
-          GraphQL::Field.define(**kwargs, &block)
-        end
-
-
-        # Attach the field to the type
-        owner_type.fields[name_s] = obj_field
-      end
-    end
-  end
-end

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Define
-    # This object delegates most methods to a dictionary of functions, {@dictionary}.
-    # {@target} is passed to the specified function, along with any arguments and block.
-    # This allows a method-based DSL without adding methods to the defined class.
-    class DefinedObjectProxy
-      extend GraphQL::Ruby2Keywords
-      # The object which will be defined by definition functions
-      attr_reader :target
-
-      def initialize(target)
-        @target = target
-        @dictionary = target.class.dictionary
-      end
-
-      # Provides shorthand access to GraphQL's built-in types
-      def types
-        GraphQL::Define::TypeDefiner.instance
-      end
-
-      # Allow `plugin` to perform complex initialization on the definition.
-      # Calls `plugin.use(defn, **kwargs)`.
-      # @param plugin [<#use(defn, **kwargs)>] A plugin object
-      # @param kwargs [Hash] Any options for the plugin
-      def use(plugin, **kwargs)
-        # https://bugs.ruby-lang.org/issues/10708
-        if kwargs == {}
-          plugin.use(self)
-        else
-          plugin.use(self, **kwargs)
-        end
-      end
-
-      # Lookup a function from the dictionary and call it if it's found.
-      ruby2_keywords
-      def method_missing(name, *args, &block)
-        definition = @dictionary[name]
-        if definition
-          definition.call(@target, *args, &block)
-        else
-          msg = "#{@target.class.name} can't define '#{name}'"
-          raise NoDefinitionError, msg, caller
-        end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        @dictionary[name] || super
-      end
-    end
-  end
-end

data/lib/graphql/define/instance_definable.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    # @api deprecated
-    module InstanceDefinable
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.ensure_defined(:metadata)
-      end
-
-      # @api deprecated
-      def metadata
-        @metadata ||= {}
-      end
-
-      # @api deprecated
-      def define(**kwargs, &block)
-        # make sure the previous definition_proc was executed:
-        ensure_defined
-        stash_dependent_methods
-        @pending_definition = Definition.new(kwargs, block)
-        nil
-      end
-
-      # @api deprecated
-      def redefine(**kwargs, &block)
-        ensure_defined
-        new_inst = self.dup
-        new_inst.define(**kwargs, &block)
-        new_inst
-      end
-
-      def initialize_copy(other)
-        super
-        @metadata = other.metadata.dup
-      end
-
-      private
-
-      # Run the definition block if it hasn't been run yet.
-      # This can only be run once: the block is deleted after it's used.
-      # You have to call this before using any value which could
-      # come from the definition block.
-      # @return [void]
-      def ensure_defined
-        if @pending_definition
-          defn = @pending_definition
-          @pending_definition = nil
-
-          revive_dependent_methods
-
-          begin
-            defn_proxy = DefinedObjectProxy.new(self)
-            # Apply definition from `define(...)` kwargs
-            defn.define_keywords.each do |keyword, value|
-              # Don't splat string hashes, which blows up on Rubies before 2.7
-              if value.is_a?(Hash) && value.each_key.all? { |k| k.is_a?(Symbol) }
-                defn_proxy.public_send(keyword, **value)
-              else
-                defn_proxy.public_send(keyword, value)
-              end
-            end
-            # and/or apply definition from `define { ... }` block
-            if defn.define_proc
-              defn_proxy.instance_eval(&defn.define_proc)
-            end
-          rescue StandardError
-            # The definition block failed to run, so make this object pending again:
-            stash_dependent_methods
-            @pending_definition = defn
-            raise
-          end
-        end
-        nil
-      end
-
-      # Take the pending methods and put them back on this object's singleton class.
-      # This reverts the process done by {#stash_dependent_methods}
-      # @return [void]
-      def revive_dependent_methods
-        pending_methods = @pending_methods
-        self.singleton_class.class_eval {
-          pending_methods.each do |method|
-            undef_method(method.name) if method_defined?(method.name)
-            define_method(method.name, method)
-          end
-        }
-        @pending_methods = nil
-      end
-
-      # Find the method names which were declared as definition-dependent,
-      # then grab the method definitions off of this object's class
-      # and store them for later.
-      #
-      # Then make a dummy method for each of those method names which:
-      #
-      # - Triggers the pending definition, if there is one
-      # - Calls the same method again.
-      #
-      # It's assumed that {#ensure_defined} will put the original method definitions
-      # back in place with {#revive_dependent_methods}.
-      # @return [void]
-      def stash_dependent_methods
-        method_names = self.class.ensure_defined_method_names
-        @pending_methods = method_names.map { |n| self.class.instance_method(n) }
-        self.singleton_class.class_eval do
-          method_names.each do |method_name|
-            undef_method(method_name) if method_defined?(method_name)
-            define_method(method_name) { |*args, &block|
-              ensure_defined
-              self.send(method_name, *args, &block)
-            }
-          end
-        end
-      end
-
-      class Definition
-        attr_reader :define_keywords, :define_proc
-        def initialize(define_keywords, define_proc)
-          @define_keywords = define_keywords
-          @define_proc = define_proc
-        end
-      end
-
-      module ClassMethods
-        # Create a new instance
-        # and prepare a definition using its {.definitions}.
-        # @param kwargs [Hash] Key-value pairs corresponding to defininitions from `accepts_definitions`
-        # @param block [Proc] Block which calls helper methods from `accepts_definitions`
-        def define(**kwargs, &block)
-          instance = self.new
-          instance.define(**kwargs, &block)
-          instance
-        end
-
-        # Attach definitions to this class.
-        # Each symbol in `accepts` will be assigned with `{key}=`.
-        # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
-        def accepts_definitions(*accepts)
-          new_assignments = if accepts.last.is_a?(Hash)
-            accepts.pop.dup
-          else
-            {}
-          end
-
-          accepts.each do |key|
-            new_assignments[key] = AssignAttribute.new(key)
-          end
-
-          @own_dictionary = own_dictionary.merge(new_assignments)
-        end
-
-        def ensure_defined(*method_names)
-          @ensure_defined_method_names ||= []
-          @ensure_defined_method_names.concat(method_names)
-          nil
-        end
-
-        def ensure_defined_method_names
-          own_method_names = @ensure_defined_method_names || []
-          if superclass.respond_to?(:ensure_defined_method_names)
-            superclass.ensure_defined_method_names + own_method_names
-          else
-            own_method_names
-          end
-        end
-
-        # @return [Hash] combined definitions for self and ancestors
-        def dictionary
-          if superclass.respond_to?(:dictionary)
-            own_dictionary.merge(superclass.dictionary)
-          else
-            own_dictionary
-          end
-        end
-
-        # @return [Hash] definitions for this class only
-        def own_dictionary
-          @own_dictionary ||= {}
-        end
-      end
-
-      class AssignMetadataKey
-        def initialize(key)
-          @key = key
-        end
-
-        def call(defn, value = true)
-          defn.metadata[@key] = value
-        end
-      end
-
-      class AssignAttribute
-        extend GraphQL::Ruby2Keywords
-
-        def initialize(attr_name)
-          @attr_assign_method = :"#{attr_name}="
-        end
-
-        # Even though we're just using the first value here,
-        # We have to add a splat here to use `ruby2_keywords`,
-        # so that it will accept a `[{}]` input from the caller.
-        ruby2_keywords
-        def call(defn, *value)
-          defn.public_send(@attr_assign_method, value.first)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/define/no_definition_error.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    class NoDefinitionError < GraphQL::Error
-    end
-  end
-end

data/lib/graphql/define/non_null_with_bang.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    # Wrap the object in NonNullType in response to `!`
-    # @example required Int type
-    #   !GraphQL::INT_TYPE
-    #
-    module NonNullWithBang
-      # Make the type non-null
-      # @return [GraphQL::NonNullType] a non-null type which wraps the original type
-      def !
-        to_non_null_type
-      end
-    end
-  end
-end

data/lib/graphql/define/type_definer.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    # Some conveniences for definining return & argument types.
-    #
-    # Passed into initialization blocks, eg {ObjectType#initialize}, {Field#initialize}
-    class TypeDefiner
-      include Singleton
-      # rubocop:disable Naming/MethodName
-      def Int;      GraphQL::INT_TYPE;      end
-      def String;   GraphQL::STRING_TYPE;   end
-      def Float;    GraphQL::FLOAT_TYPE;    end
-      def Boolean;  GraphQL::BOOLEAN_TYPE;  end
-      def ID;       GraphQL::ID_TYPE;       end
-      # rubocop:enable Naming/MethodName
-
-      # Make a {ListType} which wraps the input type
-      #
-      # @example making a list type
-      #   list_of_strings = types[types.String]
-      #   list_of_strings.inspect
-      #   # => "[String]"
-      #
-      # @param type [Type] A type to be wrapped in a ListType
-      # @return [GraphQL::ListType] A ListType wrapping `type`
-      def [](type)
-        type.to_list_type
-      end
-    end
-  end
-end

data/lib/graphql/define.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require "graphql/define/assign_argument"
-require "graphql/define/assign_connection"
-require "graphql/define/assign_enum_value"
-require "graphql/define/assign_global_id_field"
-require "graphql/define/assign_mutation_function"
-require "graphql/define/assign_object_field"
-require "graphql/define/defined_object_proxy"
-require "graphql/define/instance_definable"
-require "graphql/define/no_definition_error"
-require "graphql/define/non_null_with_bang"
-require "graphql/define/type_definer"
-
-module GraphQL
-  module Define
-    # A helper for definitions that store their value in `#metadata`.
-    #
-    # @example Storing application classes with GraphQL types
-    #   # Make a custom definition
-    #   GraphQL::ObjectType.accepts_definitions(resolves_to_class_names: GraphQL::Define.assign_metadata_key(:resolves_to_class_names))
-    #
-    #   # After definition, read the key from metadata
-    #   PostType.metadata[:resolves_to_class_names] # => [...]
-    #
-    # @param key [Object] the key to assign in metadata
-    # @return [#call(defn, value)] an assignment for `.accepts_definitions` which writes `key` to `#metadata`
-    def self.assign_metadata_key(key)
-      GraphQL::Define::InstanceDefinable::AssignMetadataKey.new(key)
-    end
-  end
-end

data/lib/graphql/deprecated_dsl.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # There are two ways to apply the deprecated `!` DSL to class-style schema definitions:
-  #
-  # 1. Scoped by file (CRuby only), add to the top of the file:
-  #
-  #      using GraphQL::DeprecatedDSL
-  #
-  #   (This is a "refinement", there are also other ways to scope it.)
-  #
-  # 2. Global application, add before schema definition:
-  #
-  #      GraphQL::DeprecatedDSL.activate
-  #
-  module DeprecatedDSL
-    TYPE_CLASSES = [
-      GraphQL::Schema::Scalar,
-      GraphQL::Schema::Enum,
-      GraphQL::Schema::InputObject,
-      GraphQL::Schema::Union,
-      GraphQL::Schema::Interface,
-      GraphQL::Schema::Object,
-    ]
-
-    def self.activate
-      TYPE_CLASSES.each { |c| c.extend(Methods) }
-      GraphQL::Schema::List.include(Methods)
-      GraphQL::Schema::NonNull.include(Methods)
-    end
-    module Methods
-      def !
-        to_non_null_type
-      end
-    end
-
-    TYPE_CLASSES.each do |type_class|
-      refine type_class.singleton_class do
-        include Methods
-      end
-    end
-  end
-end

data/lib/graphql/directive/deprecated_directive.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition

data/lib/graphql/directive/include_directive.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::Directive::IncludeDirective = GraphQL::Schema::Directive::Include.graphql_definition

data/lib/graphql/directive/skip_directive.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::Directive::SkipDirective = GraphQL::Schema::Directive::Skip.graphql_definition

data/lib/graphql/directive.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # Directives are server-defined hooks for modifying execution.
-  #
-  # Two directives are included out-of-the-box:
-  # - `@skip(if: ...)` Skips the tagged field if the value of `if` is true
-  # - `@include(if: ...)` Includes the tagged field _only_ if `if` is true
-  #
-  class Directive
-    include GraphQL::Define::InstanceDefinable
-    accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
-
-    attr_accessor :locations, :arguments, :name, :description, :arguments_class
-    attr_accessor :ast_node
-    # @api private
-    attr_writer :default_directive
-    ensure_defined(:locations, :arguments, :graphql_name, :name, :description, :default_directive?)
-
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_name :name
-
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_definition :itself
-
-    LOCATIONS = [
-      QUERY =                  :QUERY,
-      MUTATION =               :MUTATION,
-      SUBSCRIPTION =           :SUBSCRIPTION,
-      FIELD =                  :FIELD,
-      FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
-      FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
-      INLINE_FRAGMENT =        :INLINE_FRAGMENT,
-      SCHEMA =                 :SCHEMA,
-      SCALAR =                 :SCALAR,
-      OBJECT =                 :OBJECT,
-      FIELD_DEFINITION =       :FIELD_DEFINITION,
-      ARGUMENT_DEFINITION =    :ARGUMENT_DEFINITION,
-      INTERFACE =              :INTERFACE,
-      UNION =                  :UNION,
-      ENUM =                   :ENUM,
-      ENUM_VALUE =             :ENUM_VALUE,
-      INPUT_OBJECT =           :INPUT_OBJECT,
-      INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
-    ]
-
-    LOCATION_DESCRIPTIONS = {
-      QUERY:                    'Location adjacent to a query operation.',
-      MUTATION:                 'Location adjacent to a mutation operation.',
-      SUBSCRIPTION:             'Location adjacent to a subscription operation.',
-      FIELD:                    'Location adjacent to a field.',
-      FRAGMENT_DEFINITION:      'Location adjacent to a fragment definition.',
-      FRAGMENT_SPREAD:          'Location adjacent to a fragment spread.',
-      INLINE_FRAGMENT:          'Location adjacent to an inline fragment.',
-      SCHEMA:                   'Location adjacent to a schema definition.',
-      SCALAR:                   'Location adjacent to a scalar definition.',
-      OBJECT:                   'Location adjacent to an object type definition.',
-      FIELD_DEFINITION:         'Location adjacent to a field definition.',
-      ARGUMENT_DEFINITION:      'Location adjacent to an argument definition.',
-      INTERFACE:                'Location adjacent to an interface definition.',
-      UNION:                    'Location adjacent to a union definition.',
-      ENUM:                     'Location adjacent to an enum definition.',
-      ENUM_VALUE:               'Location adjacent to an enum value definition.',
-      INPUT_OBJECT:             'Location adjacent to an input object type definition.',
-      INPUT_FIELD_DEFINITION:   'Location adjacent to an input object field definition.',
-    }
-
-    def initialize
-      @arguments = {}
-      @default_directive = false
-    end
-
-    def to_s
-      "<GraphQL::Directive #{name}>"
-    end
-
-    def on_field?
-      locations.include?(FIELD)
-    end
-
-    def on_fragment?
-      locations.include?(FRAGMENT_SPREAD) && locations.include?(INLINE_FRAGMENT)
-    end
-
-    def on_operation?
-      locations.include?(QUERY) && locations.include?(MUTATION) && locations.include?(SUBSCRIPTION)
-    end
-
-    # @return [Boolean] Is this directive supplied by default? (eg `@skip`)
-    def default_directive?
-      @default_directive
-    end
-
-    def inspect
-      "#<GraphQL::Directive #{name}>"
-    end
-
-    def type_class
-      metadata[:type_class]
-    end
-  end
-end
-
-require "graphql/directive/include_directive"
-require "graphql/directive/skip_directive"
-require "graphql/directive/deprecated_directive"