graphql_cody 1.13.0

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module TypeSystemHelpers
+        # @return [Schema::NonNull] Make a non-null-type representation of this type
+        def to_non_null_type
+          @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
+        end
+
+        # @return [Schema::List] Make a list-type representation of this type
+        def to_list_type
+          @to_list_type ||= GraphQL::Schema::List.new(self)
+        end
+
+        # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.
+        def non_null?
+          false
+        end
+
+        # @return [Boolean] true if this is a list type. A non-nullable list is considered a list.
+        def list?
+          false
+        end
+
+        def to_type_signature
+          graphql_name
+        end
+
+        # @return [GraphQL::TypeKinds::TypeKind]
+        def kind
+          raise GraphQL::RequiredImplementationMissingError, "No `.kind` defined for #{self}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module ValidatesInput
+        def valid_input?(val, ctx)
+          validate_input(val, ctx).valid?
+        end
+
+        def validate_input(val, ctx)
+          if val.nil?
+            GraphQL::Query::InputValidationResult.new
+          else
+            validate_non_null_input(val, ctx)
+          end
+        end
+
+        def valid_isolated_input?(v)
+          valid_input?(v, GraphQL::Query::NullContext)
+        end
+
+        def coerce_isolated_input(v)
+          coerce_input(v, GraphQL::Query::NullContext)
+        end
+
+        def coerce_isolated_result(v)
+          coerce_result(v, GraphQL::Query::NullContext)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+require 'graphql/schema/member/accepts_definition'
+require 'graphql/schema/member/base_dsl_methods'
+require 'graphql/schema/member/cached_graphql_definition'
+require 'graphql/schema/member/graphql_type_names'
+require 'graphql/schema/member/has_ast_node'
+require 'graphql/schema/member/has_directives'
+require 'graphql/schema/member/has_deprecation_reason'
+require 'graphql/schema/member/has_interfaces'
+require 'graphql/schema/member/has_path'
+require 'graphql/schema/member/has_unresolved_type_error'
+require 'graphql/schema/member/has_validators'
+require 'graphql/schema/member/relay_shortcuts'
+require 'graphql/schema/member/scoped'
+require 'graphql/schema/member/type_system_helpers'
+require 'graphql/schema/member/validates_input'
+require "graphql/relay/type_extensions"
+
+module GraphQL
+  class Schema
+    # The base class for things that make up the schema,
+    # eg objects, enums, scalars.
+    #
+    # @api private
+    class Member
+      include GraphQLTypeNames
+      extend CachedGraphQLDefinition
+      extend GraphQL::Relay::TypeExtensions
+      extend BaseDSLMethods
+      extend BaseDSLMethods::ConfigurationExtension
+      introspection(false)
+      extend TypeSystemHelpers
+      extend Scoped
+      extend RelayShortcuts
+      extend HasPath
+      extend HasAstNode
+      extend HasDirectives
+    end
+
+    #   # The legacy handler is called, as before:
+    #   Account.graphql_definition.metadata[:permission_level] # => 1
+    module AcceptsDefinition
+
+      def self.included(child)
+        child.extend(AcceptsDefinitionDefinitionMethods)
+        child.prepend(ToGraphQLExtension)
+        child.prepend(InitializeExtension)
+      end
+
+      def self.extended(child)
+        if defined?(child::DefinitionMethods)
+          child::DefinitionMethods.include(AcceptsDefinitionDefinitionMethods)
+          child::DefinitionMethods.prepend(ToGraphQLExtension)
+        else
+          child.extend(AcceptsDefinitionDefinitionMethods)
+          # I tried to use `super`, but super isn't quite right
+          # since the method is defined in the same class itself,
+          # not the superclass
+          child.class_eval do
+            class << self
+              prepend(ToGraphQLExtension)
+            end
+          end
+        end
+      end
+
+      module AcceptsDefinitionDefinitionMethods
+        def accepts_definition(name)
+          own_accepts_definition_methods << name
+
+          ivar_name = "@#{name}_args"
+          if self.is_a?(Class)
+            define_singleton_method(name) do |*args|
+              if args.any?
+                instance_variable_set(ivar_name, args)
+              end
+              instance_variable_get(ivar_name) || (superclass.respond_to?(name) ? superclass.public_send(name) : nil)
+            end
+
+            define_method(name) do |*args|
+              if args.any?
+                instance_variable_set(ivar_name, args)
+              end
+              instance_variable_get(ivar_name)
+            end
+          else
+            # Special handling for interfaces, define it here
+            # so it's appropriately passed down
+            self::DefinitionMethods.module_eval do
+              define_method(name) do |*args|
+                if args.any?
+                  instance_variable_set(ivar_name, args)
+                end
+                instance_variable_get(ivar_name) || ((int = interfaces.first { |i| i.respond_to?()}) && int.public_send(name))
+              end
+            end
+          end
+        end
+
+        def accepts_definition_methods
+          inherited_methods = if self.is_a?(Class)
+                                superclass.respond_to?(:accepts_definition_methods) ? superclass.accepts_definition_methods : []
+                              elsif self.is_a?(Module)
+                                m = []
+                                ancestors.each do |a|
+                                  if a.respond_to?(:own_accepts_definition_methods)
+                                    m.concat(a.own_accepts_definition_methods)
+                                  end
+                                end
+                                m
+                              else
+                                self.class.accepts_definition_methods
+                              end
+
+          own_accepts_definition_methods + inherited_methods
+        end
+
+        def own_accepts_definition_methods
+          @own_accepts_definition_methods ||= []
+        end
+      end
+
+      module ToGraphQLExtension
+        def to_graphql
+          defn = super
+          accepts_definition_methods.each do |method_name|
+            value = public_send(method_name)
+            if !value.nil?
+              defn = defn.redefine { public_send(method_name, *value) }
+            end
+          end
+          defn
+        end
+      end
+
+      module InitializeExtension
+        def initialize(*args, **kwargs, &block)
+          self.class.accepts_definition_methods.each do |method_name|
+            if kwargs.key?(method_name)
+              value = kwargs.delete(method_name)
+              if !value.is_a?(Array)
+                value = [value]
+              end
+              instance_variable_set("@#{method_name}_args", value)
+            end
+          end
+          super(*args, **kwargs, &block)
+        end
+
+        def accepts_definition_methods
+          self.class.accepts_definition_methods
+        end
+      end
+    end
+  end
+end
+
+require 'graphql/schema/member/has_arguments'
+require 'graphql/schema/member/has_fields'
+require 'graphql/schema/member/instrumentation'
+require 'graphql/schema/member/build_type'

data/lib/graphql/schema/middleware_chain.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Given {steps} and {arguments}, call steps in order, passing `(*arguments, next_step)`.
+    #
+    # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
+    class MiddlewareChain
+      extend Forwardable
+
+      # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
+      attr_reader :steps, :final_step
+
+      def initialize(steps: [], final_step: nil)
+        @steps = steps
+        @final_step = final_step
+      end
+
+      def initialize_copy(other)
+        super
+        @steps = other.steps.dup
+      end
+
+      def_delegators :@steps, :[], :first, :insert, :delete
+
+      def <<(callable)
+        add_middleware(callable)
+      end
+
+      def push(callable)
+        add_middleware(callable)
+      end
+
+      def ==(other)
+        steps == other.steps && final_step == other.final_step
+      end
+
+      def invoke(arguments)
+        invoke_core(0, arguments)
+      end
+
+      def concat(callables)
+        callables.each { |c| add_middleware(c) }
+      end
+
+      private
+
+      def invoke_core(index, arguments)
+        if index >= steps.length
+          final_step.call(*arguments)
+        else
+          steps[index].call(*arguments) { |next_args = arguments| invoke_core(index + 1, next_args) }
+        end
+      end
+
+      def add_middleware(callable)
+        # TODO: Stop wrapping callables once deprecated middleware becomes unsupported
+        steps << wrap(callable)
+      end
+
+      # TODO: Remove this code once deprecated middleware becomes unsupported
+      class MiddlewareWrapper
+        attr_reader :callable
+        def initialize(callable)
+          @callable = callable
+        end
+
+        def call(*args, &next_middleware)
+          callable.call(*args, next_middleware)
+        end
+      end
+
+      def wrap(callable)
+        if BackwardsCompatibility.get_arity(callable) == 6
+          GraphQL::Deprecation.warn("Middleware that takes a next_middleware parameter is deprecated (#{callable.inspect}); instead, accept a block and use yield.")
+          MiddlewareWrapper.new(callable)
+        else
+          callable
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/mutation.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This base class accepts configuration for a mutation root field,
+    # then it can be hooked up to your mutation root object type.
+    #
+    # If you want to customize how this class generates types, in your base class,
+    # override the various `generate_*` methods.
+    #
+    # @see {GraphQL::Schema::RelayClassicMutation} for an extension of this class with some conventions built-in.
+    #
+    # @example Creating a comment
+    #  # Define the mutation:
+    #  class Mutations::CreateComment < GraphQL::Schema::Mutation
+    #    argument :body, String, required: true
+    #    argument :post_id, ID, required: true
+    #
+    #    field :comment, Types::Comment, null: true
+    #    field :errors, [String], null: false
+    #
+    #    def resolve(body:, post_id:)
+    #      post = Post.find(post_id)
+    #      comment = post.comments.build(body: body, author: context[:current_user])
+    #      if comment.save
+    #        # Successful creation, return the created object with no errors
+    #        {
+    #          comment: comment,
+    #          errors: [],
+    #        }
+    #      else
+    #        # Failed save, return the errors to the client
+    #        {
+    #          comment: nil,
+    #          errors: comment.errors.full_messages
+    #        }
+    #      end
+    #    end
+    #  end
+    #
+    #  # Hook it up to your mutation:
+    #  class Types::Mutation < GraphQL::Schema::Object
+    #    field :create_comment, mutation: Mutations::CreateComment
+    #  end
+    #
+    #  # Call it from GraphQL:
+    #  result = MySchema.execute <<-GRAPHQL
+    #  mutation {
+    #    createComment(postId: "1", body: "Nice Post!") {
+    #      errors
+    #      comment {
+    #        body
+    #        author {
+    #          login
+    #        }
+    #      }
+    #    }
+    #  }
+    #  GRAPHQL
+    #
+    class Mutation < GraphQL::Schema::Resolver
+      extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Resolver::HasPayloadType
+
+      class << self
+        # Override this method to handle legacy-style usages of `MyMutation.field`
+        def field(*args, **kwargs, &block)
+          if args.empty?
+            raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
+          else
+            super
+          end
+        end
+
+        def visible?(context)
+          true
+        end
+
+        private
+
+        def conflict_field_name_warning(field_defn)
+          "#{self.graphql_name}'s `field :#{field_defn.name}` conflicts with a built-in method, use `hash_key:` or `method:` to pick a different resolve behavior for this field (for example, `hash_key: :#{field_defn.resolver_method}_value`, and modify the return hash). Or use `method_conflict_warning: false` to suppress this warning."
+        end
+
+        # Override this to attach self as `mutation`
+        def generate_payload_type
+          payload_class = super
+          payload_class.mutation(self)
+          payload_class
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/non_null.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Represents a non null type in the schema.
+    # Wraps a {Schema::Member} when it is required.
+    # @see {Schema::Member::TypeSystemHelpers#to_non_null_type}
+    class NonNull < GraphQL::Schema::Wrapper
+      include Schema::Member::ValidatesInput
+
+      def to_graphql
+        @of_type.graphql_definition.to_non_null_type
+      end
+
+       # @return [GraphQL::TypeKinds::NON_NULL]
+      def kind
+        GraphQL::TypeKinds::NON_NULL
+      end
+
+      # @return [true]
+      def non_null?
+        true
+      end
+
+      # @return [Boolean] True if this type wraps a list type
+      def list?
+        @of_type.list?
+      end
+
+      def to_type_signature
+        "#{@of_type.to_type_signature}!"
+      end
+
+      def inspect
+        "#<#{self.class.name} @of_type=#{@of_type.inspect}>"
+      end
+
+      def validate_input(value, ctx)
+        if value.nil?
+          result = GraphQL::Query::InputValidationResult.new
+          result.add_problem("Expected value to not be null")
+          result
+        else
+          of_type.validate_input(value, ctx)
+        end
+      end
+
+      # This is for introspection, where it's expected the name will be `null`
+      def graphql_name
+        nil
+      end
+
+      def coerce_input(value, ctx)
+        of_type.coerce_input(value, ctx)
+      end
+
+      def coerce_result(value, ctx)
+        of_type.coerce_result(value, ctx)
+      end
+
+      # This is for implementing introspection
+      def description
+        nil
+      end
+    end
+  end
+end

data/lib/graphql/schema/null_mask.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # @api private
+    module NullMask
+      def self.call(member, ctx)
+        false
+      end
+    end
+  end
+end

data/lib/graphql/schema/object.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "graphql/query/null_context"
+
+module GraphQL
+  class Schema
+    class Object < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Member::HasInterfaces
+
+      # @return [Object] the application object this type is wrapping
+      attr_reader :object
+
+      # @return [GraphQL::Query::Context] the context instance for this query
+      attr_reader :context
+
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
+      # Call this in a field method to return a value that should be returned to the client
+      # without any further handling by GraphQL.
+      def raw_value(obj)
+        GraphQL::Execution::Interpreter::RawValue.new(obj)
+      end
+
+      class << self
+        # This is protected so that we can be sure callers use the public method, {.authorized_new}
+        # @see authorized_new to make instances
+        protected :new
+
+        # Make a new instance of this type _if_ the auth check passes,
+        # otherwise, raise an error.
+        #
+        # Probably only the framework should call this method.
+        #
+        # This might return a {GraphQL::Execution::Lazy} if the user-provided `.authorized?`
+        # hook returns some lazy value (like a Promise).
+        #
+        # The reason that the auth check is in this wrapper method instead of {.new} is because
+        # of how it might return a Promise. It would be weird if `.new` returned a promise;
+        # It would be a headache to try to maintain Promise-y state inside a {Schema::Object}
+        # instance. So, hopefully this wrapper method will do the job.
+        #
+        # @param object [Object] The thing wrapped by this object
+        # @param context [GraphQL::Query::Context]
+        # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
+        # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
+        def authorized_new(object, context)
+          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
+
+          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+            context.query.with_error_handling do
+              begin
+                authorized?(object, context)
+              rescue GraphQL::UnauthorizedError => err
+                context.schema.unauthorized_object(err)
+              end
+            end
+          end
+
+          auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
+            GraphQL::Execution::Lazy.new do
+              context.query.trace("authorized_lazy", trace_payload) do
+                context.schema.sync_lazy(maybe_lazy_auth_val)
+              end
+            end
+          else
+            maybe_lazy_auth_val
+          end
+
+          context.schema.after_lazy(auth_val) do |is_authorized|
+            if is_authorized
+              self.new(object, context)
+            else
+              # It failed the authorization check, so go to the schema's authorized object hook
+              err = GraphQL::UnauthorizedError.new(object: object, type: self, context: context)
+              # If a new value was returned, wrap that instead of the original value
+              begin
+                new_obj = context.schema.unauthorized_object(err)
+                if new_obj
+                  self.new(new_obj, context)
+                else
+                  nil
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(object, context)
+        @object = object
+        @context = context
+      end
+
+      class << self
+        # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
+        # It should help with debugging and bug tracker integrations.
+        def inherited(child_class)
+          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
+          super
+        end
+
+        # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
+        # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
+        def fields(context = GraphQL::Query::NullContext)
+          all_fields = super
+          # This adds fields from legacy-style interfaces only.
+          # Multi-fields are not supported here.
+          interfaces.each do |int|
+            if int.is_a?(GraphQL::InterfaceType)
+              int_f = {}
+              int.fields.each do |name, legacy_field| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+                int_f[name] = field_class.from_options(name, field: legacy_field)
+              end
+              all_fields = int_f.merge(all_fields)
+            end
+          end
+          all_fields
+        end
+
+        # @return [GraphQL::ObjectType]
+        def to_graphql
+          obj_type = GraphQL::ObjectType.new
+          obj_type.name = graphql_name
+          obj_type.description = description
+          obj_type.structural_interface_type_memberships = interface_type_memberships
+          obj_type.introspection = introspection
+          obj_type.mutation = mutation
+          obj_type.ast_node = ast_node
+          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+            field_defn = field_inst.to_graphql
+            obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+          end
+
+          obj_type.metadata[:type_class] = self
+
+          obj_type
+        end
+
+        def kind
+          GraphQL::TypeKinds::OBJECT
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/possible_types.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Find the members of a union or interface within a given schema.
+    #
+    # (Although its members never change, unions are handled this way to simplify execution code.)
+    #
+    # Internally, the calculation is cached. It's assumed that schema members _don't_ change after creating the schema!
+    #
+    # @example Get an interface's possible types
+    #   possible_types = GraphQL::Schema::PossibleTypes(MySchema)
+    #   possible_types.possible_types(MyInterface)
+    #   # => [MyObjectType, MyOtherObjectType]
+    class PossibleTypes
+      def initialize(schema)
+        @object_types = schema.types.values.select { |type| type.kind.object? }
+        @interface_implementers = Hash.new do |h1, ctx|
+          h1[ctx] = Hash.new do |h2, int_type|
+            h2[int_type] = @object_types.select { |type| type.interfaces(ctx).include?(int_type) }.sort_by(&:name)
+          end
+        end
+      end
+
+      def possible_types(type_defn, ctx)
+        case type_defn
+        when Module
+          possible_types(type_defn.graphql_definition, ctx)
+        when GraphQL::UnionType
+          type_defn.possible_types(ctx)
+        when GraphQL::InterfaceType
+          interface_implementers(ctx, type_defn)
+        when GraphQL::BaseType
+          [type_defn]
+        else
+          raise "Unexpected possible_types object: #{type_defn.inspect}"
+        end
+      end
+
+      def interface_implementers(ctx, type_defn)
+        @interface_implementers[ctx][type_defn]
+      end
+    end
+  end
+end