graphql 1.9.21 → 2.0.0

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
-    # Turn enum value configs into a {GraphQL::EnumType::EnumValue} and register it with the {GraphQL::EnumType}
-    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
-    # Turn field configs into a {GraphQL::Field} and attach it to a {GraphQL::ObjectType} or {GraphQL::InterfaceType}
-    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,311 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Define
-    # This module provides the `.define { ... }` API for
-    # {GraphQL::BaseType}, {GraphQL::Field} and others.
-    #
-    # Calling `.accepts_definitions(...)` creates:
-    #
-    # - a keyword to the `.define` method
-    # - a helper method in the `.define { ... }` block
-    #
-    # The `.define { ... }` block will be called lazily. To be sure it has been
-    # called, use the private method `#ensure_defined`. That will call the
-    # definition block if it hasn't been called already.
-    #
-    # The goals are:
-    #
-    # - Minimal overhead in consuming classes
-    # - Independence between consuming classes
-    # - Extendable by third-party libraries without monkey-patching or other nastiness
-    #
-    # @example Make a class definable
-    #   class Car
-    #     include GraphQL::Define::InstanceDefinable
-    #     attr_accessor :make, :model, :doors
-    #     accepts_definitions(
-    #       # These attrs will be defined with plain setters, `{attr}=`
-    #       :make, :model,
-    #       # This attr has a custom definition which applies the config to the target
-    #       doors: ->(car, doors_count) { doors_count.times { car.doors << Door.new } }
-    #     )
-    #     ensure_defined(:make, :model, :doors)
-    #
-    #     def initialize
-    #       @doors = []
-    #     end
-    #   end
-    #
-    #   class Door; end;
-    #
-    #   # Create an instance with `.define`:
-    #   subaru_baja = Car.define do
-    #     make "Subaru"
-    #     model "Baja"
-    #     doors 4
-    #   end
-    #
-    #   # The custom proc was applied:
-    #   subaru_baja.doors #=> [<Door>, <Door>, <Door>, <Door>]
-    #
-    # @example Extending the definition of a class
-    #   # Add some definitions:
-    #   Car.accepts_definitions(all_wheel_drive: GraphQL::Define.assign_metadata_key(:all_wheel_drive))
-    #
-    #   # Use it in a definition
-    #   subaru_baja = Car.define do
-    #     # ...
-    #     all_wheel_drive true
-    #   end
-    #
-    #   # Access it from metadata
-    #   subaru_baja.metadata[:all_wheel_drive] # => true
-    #
-    # @example Extending the definition of a class via a plugin
-    #   # A plugin is any object that responds to `.use(definition)`
-    #   module SubaruCar
-    #     extend self
-    #
-    #     def use(defn)
-    #       # `defn` has the same methods as within `.define { ... }` block
-    #       defn.make "Subaru"
-    #       defn.doors 4
-    #     end
-    #   end
-    #
-    #   # Use the plugin within a `.define { ... }` block
-    #   subaru_baja = Car.define do
-    #     use SubaruCar
-    #     model 'Baja'
-    #   end
-    #
-    #   subaru_baja.make # => "Subaru"
-    #   subaru_baja.doors # => [<Door>, <Door>, <Door>, <Door>]
-    #
-    # @example Making a copy with an extended definition
-    #   # Create an instance with `.define`:
-    #   subaru_baja = Car.define do
-    #     make "Subaru"
-    #     model "Baja"
-    #     doors 4
-    #   end
-    #
-    #   # Then extend it with `#redefine`
-    #   two_door_baja = subaru_baja.redefine do
-    #     doors 2
-    #   end
-    module InstanceDefinable
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.ensure_defined(:metadata)
-      end
-
-      # `metadata` can store arbitrary key-values with an object.
-      #
-      # @return [Hash<Object, Object>] Hash for user-defined storage
-      def metadata
-        @metadata ||= {}
-      end
-
-      # Mutate this instance using functions from its {.definition}s.
-      # Keywords or helpers in the block correspond to keys given to `accepts_definitions`.
-      #
-      # Note that the block is not called right away -- instead, it's deferred until
-      # one of the defined fields is needed.
-      # @return [void]
-      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
-
-      # Shallow-copy this object, then apply new definitions to the copy.
-      # @see {#define} for arguments
-      # @return [InstanceDefinable] A new instance, with any extended definitions
-      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.empty? && 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,13 +0,0 @@
-# frozen_string_literal: true
-GraphQL::Directive::DeprecatedDirective = GraphQL::Directive.define do
-  name "deprecated"
-  description "Marks an element of a GraphQL schema as no longer supported."
-  locations([GraphQL::Directive::FIELD_DEFINITION, GraphQL::Directive::ENUM_VALUE])
-
-  reason_description = "Explains why this element was deprecated, usually also including a "\
-    "suggestion for how to access supported similar data. Formatted "\
-    "in [Markdown](https://daringfireball.net/projects/markdown/)."
-
-  argument :reason, GraphQL::STRING_TYPE, reason_description, default_value: GraphQL::Directive::DEFAULT_DEPRECATION_REASON
-  default_directive true
-end

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