graphql_cody 1.13.0

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "graphql/schema/find_inherited_value"
+
+module GraphQL
+  class Schema
+    class Member
+      # DSL methods shared by lots of things in the GraphQL Schema.
+      # @api private
+      # @see Classes that extend this, eg {GraphQL::Schema::Object}
+      module BaseDSLMethods
+        include GraphQL::Schema::FindInheritedValue
+
+        # Call this with a new name to override the default name for this schema member; OR
+        # call it without an argument to get the name of this schema member
+        #
+        # The default name is implemented in default_graphql_name
+        # @param new_name [String]
+        # @return [String]
+        def graphql_name(new_name = nil)
+          if new_name
+            GraphQL::NameValidator.validate!(new_name)
+            @graphql_name = new_name
+          else
+            overridden_graphql_name || default_graphql_name
+          end
+        end
+
+        def overridden_graphql_name
+          defined?(@graphql_name) ? @graphql_name : nil
+        end
+
+        # Just a convenience method to point out that people should use graphql_name instead
+        def name(new_name = nil)
+          return super() if new_name.nil?
+
+          fail(
+            "The new name override method is `graphql_name`, not `name`. Usage: "\
+            "graphql_name \"#{new_name}\""
+          )
+        end
+
+        # Call this method to provide a new description; OR
+        # call it without an argument to get the description
+        # @param new_description [String]
+        # @return [String]
+        def description(new_description = nil)
+          if new_description
+            @description = new_description
+          elsif defined?(@description)
+            @description
+          else
+            nil
+          end
+        end
+
+        # This pushes some configurations _down_ the inheritance tree,
+        # in order to prevent repetitive lookups at runtime.
+        module ConfigurationExtension
+          def inherited(child_class)
+            child_class.introspection(introspection)
+            child_class.description(description)
+            if overridden_graphql_name
+              child_class.graphql_name(overridden_graphql_name)
+            end
+            super
+          end
+        end
+
+        # @return [Boolean] If true, this object is part of the introspection system
+        def introspection(new_introspection = nil)
+          if !new_introspection.nil?
+            @introspection = new_introspection
+          elsif defined?(@introspection)
+            @introspection
+          else
+            false
+          end
+        end
+
+        def introspection?
+          introspection
+        end
+
+        # The mutation this type was derived from, if it was derived from a mutation
+        # @return [Class]
+        def mutation(mutation_class = nil)
+          if mutation_class
+            @mutation = mutation_class
+          elsif defined?(@mutation)
+            @mutation
+          else
+            nil
+          end
+        end
+
+        # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
+        def to_graphql
+          raise GraphQL::RequiredImplementationMissingError
+        end
+
+        alias :unwrap :itself
+
+        # Creates the default name for a schema member.
+        # The default name is the Ruby constant name,
+        # without any namespaces and with any `-Type` suffix removed
+        def default_graphql_name
+          @default_graphql_name ||= begin
+            raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
+
+            name.split("::").last.sub(/Type\Z/, "")
+          end
+        end
+
+        def visible?(context)
+          true
+        end
+
+        def accessible?(context)
+          true
+        end
+
+        def authorized?(object, context)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      # @api private
+      module BuildType
+        LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
+
+        module_function
+        # @param type_expr [String, Class, GraphQL::BaseType]
+        # @return [GraphQL::BaseType]
+        def parse_type(type_expr, null:)
+          list_type = false
+
+          return_type = case type_expr
+          when String
+            case type_expr
+            when "String"
+              GraphQL::Types::String
+            when "Int", "Integer"
+              GraphQL::Types::Int
+            when "Float"
+              GraphQL::Types::Float
+            when "Boolean"
+              GraphQL::Types::Boolean
+            when "ID"
+              GraphQL::Types::ID
+            when /\A\[.*\]\Z/
+              list_type = true
+              # List members are required by default
+              parse_type(type_expr[1..-2], null: false)
+            when /.*!\Z/
+              null = false
+              parse_type(type_expr[0..-2], null: true)
+            else
+              maybe_type = constantize(type_expr)
+              case maybe_type
+              when GraphQL::BaseType
+                maybe_type
+              when Module
+                # This is a way to check that it's the right kind of module:
+                if maybe_type.respond_to?(:graphql_definition)
+                  maybe_type
+                else
+                  raise ArgumentError, "Unexpected class/module found for GraphQL type: #{type_expr} (must be type definition class/module)"
+                end
+              end
+            end
+          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+            type_expr
+          when Array
+            case type_expr.length
+            when 1
+              list_type = true
+              # List members are required by default
+              parse_type(type_expr.first, null: false)
+            when 2
+              inner_type, nullable_option = type_expr
+              if nullable_option.keys != [:null] || (nullable_option[:null] != true && nullable_option[:null] != false)
+                raise ArgumentError, LIST_TYPE_ERROR
+              end
+              list_type = true
+              parse_type(inner_type, null: nullable_option[:null])
+            else
+              raise ArgumentError, LIST_TYPE_ERROR
+            end
+          when GraphQL::Schema::NonNull, GraphQL::Schema::List
+            type_expr
+          when Module
+            # This is a way to check that it's the right kind of module:
+            if type_expr.respond_to?(:graphql_definition)
+              type_expr
+            else
+              # Eg `String` => GraphQL::Types::String
+              parse_type(type_expr.name, null: true)
+            end
+          when Proc
+            parse_type(type_expr.call, null: true)
+          when false
+            raise ArgumentError, "Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
+          end
+
+          if return_type.nil?
+            raise "Unexpected type input: #{type_expr.inspect} (#{type_expr.class})"
+          end
+
+          # Apply list_type first, that way the
+          # .to_non_null_type applies to the list type, not the inner type
+          if list_type
+            return_type = return_type.to_list_type
+          end
+
+          if !null
+            return_type = return_type.to_non_null_type
+          end
+
+
+          return_type
+        end
+
+        def to_type_name(something)
+          case something
+          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+            something.unwrap.name
+          when Array
+            to_type_name(something.first)
+          when Module
+            if something.respond_to?(:graphql_name)
+              something.graphql_name
+            else
+              to_type_name(something.name)
+            end
+          when String
+            something.gsub(/\]\[\!/, "").split("::").last
+          when GraphQL::Schema::NonNull, GraphQL::Schema::List
+            to_type_name(something.unwrap)
+          else
+            raise "Unhandled to_type_name input: #{something} (#{something.class})"
+          end
+        end
+
+        def camelize(string)
+          return string if string == '_'
+          return string unless string.include?("_")
+          camelized = string.split('_').map(&:capitalize).join
+          camelized[0] = camelized[0].downcase
+          if (match_data = string.match(/\A(_+)/))
+            camelized = "#{match_data[0]}#{camelized}"
+          end
+          camelized
+        end
+
+        # Resolves constant from string (based on Rails `ActiveSupport::Inflector.constantize`)
+        def constantize(string)
+          names = string.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(string) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+              next candidate if constant.const_defined?(name, false)
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+
+              # Owner is in Object, so raise.
+              constant.const_get(name, false)
+            end
+          end
+        end
+
+        def underscore(string)
+          if string.match?(/\A[a-z_]+\Z/)
+            return string
+          end
+          string2 = string.dup
+
+          string2.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+          string2.gsub!(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+          string2.downcase!
+
+          string2
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Adds a layer of caching over user-supplied `.to_graphql` methods.
+      # Users override `.to_graphql`, but all runtime code should use `.graphql_definition`.
+      # @api private
+      # @see concrete classes that extend this, eg {Schema::Object}
+      module CachedGraphQLDefinition
+        # A cached result of {.to_graphql}.
+        # It's cached here so that user-overridden {.to_graphql} implementations
+        # are also cached
+        def graphql_definition
+          @graphql_definition ||= to_graphql
+        end
+
+        # This is for a common interface with .define-based types
+        def type_class
+          self
+        end
+
+        # Wipe out the cached graphql_definition so that `.to_graphql` will be called again.
+        def initialize_copy(original)
+          super
+          @graphql_definition = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # These constants are interpreted as GraphQL types when defining fields or arguments
+      #
+      # @example
+      #   field :is_draft, Boolean, null: false
+      #   field :id, ID, null: false
+      #   field :score, Int, null: false
+      #
+      # @api private
+      module GraphQLTypeNames
+        Boolean = "Boolean"
+        ID = "ID"
+        Int = "Int"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasArguments
+        def self.included(cls)
+          cls.extend(ArgumentClassAccessor)
+          cls.include(ArgumentObjectLoader)
+        end
+
+        def self.extended(cls)
+          cls.extend(ArgumentClassAccessor)
+          cls.include(ArgumentObjectLoader)
+        end
+
+        # @see {GraphQL::Schema::Argument#initialize} for parameters
+        # @return [GraphQL::Schema::Argument] An instance of {arguments_class}, created from `*args`
+        def argument(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          loads = kwargs[:loads]
+          if loads
+            name = args[0]
+            name_as_string = name.to_s
+
+            inferred_arg_name = case name_as_string
+            when /_id$/
+              name_as_string.sub(/_id$/, "").to_sym
+            when /_ids$/
+              name_as_string.sub(/_ids$/, "")
+                .sub(/([^s])$/, "\\1s")
+                .to_sym
+            else
+              name
+            end
+
+            kwargs[:as] ||= inferred_arg_name
+          end
+          arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          add_argument(arg_defn)
+
+          if self.is_a?(Class) && !method_defined?(:"load_#{arg_defn.keyword}")
+            method_owner = if self < GraphQL::Schema::InputObject || self < GraphQL::Schema::Directive
+              "self."
+            elsif self < GraphQL::Schema::Resolver
+              ""
+            else
+              raise "Unexpected argument owner: #{self}"
+            end
+            if loads && arg_defn.type.list?
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_owner}load_#{arg_defn.keyword}(values, context = nil)
+                argument = get_argument("#{arg_defn.graphql_name}")
+                (context || self.context).schema.after_lazy(values) do |values2|
+                  GraphQL::Execution::Lazy.all(values2.map { |value| load_application_object(argument, value, context || self.context) })
+                end
+              end
+              RUBY
+            elsif loads
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_owner}load_#{arg_defn.keyword}(value, context = nil)
+                argument = get_argument("#{arg_defn.graphql_name}")
+                load_application_object(argument, value, context || self.context)
+              end
+              RUBY
+            else
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_owner}load_#{arg_defn.keyword}(value, _context = nil)
+                value
+              end
+              RUBY
+            end
+          end
+          arg_defn
+        end
+
+        # Register this argument with the class.
+        # @param arg_defn [GraphQL::Schema::Argument]
+        # @return [GraphQL::Schema::Argument]
+        def add_argument(arg_defn)
+          @own_arguments ||= {}
+          prev_defn = own_arguments[arg_defn.name]
+          case prev_defn
+          when nil
+            own_arguments[arg_defn.name] = arg_defn
+          when Array
+            prev_defn << arg_defn
+          when GraphQL::Schema::Argument
+            own_arguments[arg_defn.name] = [prev_defn, arg_defn]
+          else
+            raise "Invariant: unexpected `@own_arguments[#{arg_defn.name.inspect}]`: #{prev_defn.inspect}"
+          end
+          arg_defn
+        end
+
+        # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
+        def arguments(context = GraphQL::Query::NullContext)
+          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments(context) : nil)
+          # Local definitions override inherited ones
+          if own_arguments.any?
+            own_arguments_that_apply = {}
+            own_arguments.each do |name, args_entry|
+              if (visible_defn = Warden.visible_entry?(:visible_argument?, args_entry, context))
+                own_arguments_that_apply[visible_defn.graphql_name] = visible_defn
+              end
+            end
+          end
+
+          if inherited_arguments
+            if own_arguments_that_apply
+              inherited_arguments.merge(own_arguments_that_apply)
+            else
+              inherited_arguments
+            end
+          else
+            # might be nil if there are actually no arguments
+            own_arguments_that_apply || own_arguments
+          end
+        end
+
+        def all_argument_definitions
+          if self.is_a?(Class)
+            all_defns = {}
+            ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_arguments)
+                all_defns.merge!(ancestor.own_arguments)
+              end
+            end
+          else
+            all_defns = own_arguments
+          end
+          all_defns = all_defns.values
+          all_defns.flatten!
+          all_defns
+        end
+
+        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
+        def get_argument(argument_name, context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          if !self.is_a?(Class)
+            a = own_arguments[argument_name]
+            a && Warden.visible_entry?(:visible_argument?, a, context, warden)
+          else
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_arguments) &&
+                (a = ancestor.own_arguments[argument_name]) &&
+                (a = Warden.visible_entry?(:visible_argument?, a, context, warden))
+                return a
+              end
+            end
+            nil
+          end
+        end
+
+        # @param new_arg_class [Class] A class to use for building argument definitions
+        def argument_class(new_arg_class = nil)
+          self.class.argument_class(new_arg_class)
+        end
+
+        # @api private
+        # If given a block, it will eventually yield the loaded args to the block.
+        #
+        # If no block is given, it will immediately dataload (but might return a Lazy).
+        #
+        # @param values [Hash<String, Object>]
+        # @param context [GraphQL::Query::Context]
+        # @yield [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        def coerce_arguments(parent_object, values, context, &block)
+          # Cache this hash to avoid re-merging it
+          arg_defns = self.arguments(context)
+          total_args_count = arg_defns.size
+
+          finished_args = nil
+          prepare_finished_args = -> {
+            if total_args_count == 0
+              finished_args = GraphQL::Execution::Interpreter::Arguments::EMPTY
+              if block_given?
+                block.call(finished_args)
+              end
+            else
+              argument_values = {}
+              resolved_args_count = 0
+              raised_error = false
+              arg_defns.each do |arg_name, arg_defn|
+                context.dataloader.append_job do
+                  begin
+                    arg_defn.coerce_into_values(parent_object, values, context, argument_values)
+                  rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
+                    raised_error = true
+                    finished_args = err
+                    if block_given?
+                      block.call(finished_args)
+                    end
+                  end
+
+                  resolved_args_count += 1
+                  if resolved_args_count == total_args_count && !raised_error
+                    finished_args = context.schema.after_any_lazies(argument_values.values) {
+                      GraphQL::Execution::Interpreter::Arguments.new(
+                        argument_values: argument_values,
+                      )
+                    }
+                    if block_given?
+                      block.call(finished_args)
+                    end
+                  end
+                end
+              end
+            end
+          }
+
+          if block_given?
+            prepare_finished_args.call
+            nil
+          else
+            # This API returns eagerly, gotta run it now
+            context.dataloader.run_isolated(&prepare_finished_args)
+            finished_args
+          end
+        end
+
+        # Usually, this is validated statically by RequiredArgumentsArePresent,
+        # but not for directives.
+        # TODO apply static validations on schema definitions?
+        def validate_directive_argument(arg_defn, value)
+          if arg_defn.owner.is_a?(Class) && arg_defn.owner < GraphQL::Schema::Directive
+            if value.nil? && arg_defn.type.non_null?
+              raise ArgumentError, "#{arg_defn.path} is required, but no value was given"
+            end
+          end
+        end
+
+        def arguments_statically_coercible?
+          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
+
+          @arguments_statically_coercible = all_argument_definitions.all?(&:statically_coercible?)
+        end
+
+        module ArgumentClassAccessor
+          def argument_class(new_arg_class = nil)
+            if new_arg_class
+              @argument_class = new_arg_class
+            elsif defined?(@argument_class) && @argument_class
+              @argument_class
+            else
+              superclass.respond_to?(:argument_class) ? superclass.argument_class : GraphQL::Schema::Argument
+            end
+          end
+        end
+
+        module ArgumentObjectLoader
+          # Look up the corresponding object for a provided ID.
+          # By default, it uses Relay-style {Schema.object_from_id},
+          # override this to find objects another way.
+          #
+          # @param type [Class, Module] A GraphQL type definition
+          # @param id [String] A client-provided to look up
+          # @param context [GraphQL::Query::Context] the current context
+          def object_from_id(type, id, context)
+            context.schema.object_from_id(id, context)
+          end
+
+          def load_application_object(argument, id, context)
+            # See if any object can be found for this ID
+            if id.nil?
+              return nil
+            end
+            object_from_id(argument.loads, id, context)
+          end
+
+          def load_and_authorize_application_object(argument, id, context)
+            loaded_application_object = load_application_object(argument, id, context)
+            authorize_application_object(argument, id, context, loaded_application_object)
+          end
+
+          def authorize_application_object(argument, id, context, loaded_application_object)
+            context.schema.after_lazy(loaded_application_object) do |application_object|
+              if application_object.nil?
+                err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+                load_application_object_failed(err)
+              end
+              # Double-check that the located object is actually of this type
+              # (Don't want to allow arbitrary access to objects this way)
+              resolved_application_object_type = context.schema.resolve_type(argument.loads, application_object, context)
+              context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
+                possible_object_types = context.warden.possible_types(argument.loads)
+                if !possible_object_types.include?(application_object_type)
+                  err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+                  load_application_object_failed(err)
+                else
+                  # This object was loaded successfully
+                  # and resolved to the right type,
+                  # now apply the `.authorized?` class method if there is one
+                  if (class_based_type = application_object_type.type_class)
+                    context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
+                      if authed
+                        application_object
+                      else
+                        err = GraphQL::UnauthorizedError.new(
+                          object: application_object,
+                          type: class_based_type,
+                          context: context,
+                        )
+                        if self.respond_to?(:unauthorized_object)
+                          err.set_backtrace(caller)
+                          unauthorized_object(err)
+                        else
+                          raise err
+                        end
+                      end
+                    end
+                  else
+                    application_object
+                  end
+                end
+              end
+            end
+          end
+
+          def load_application_object_failed(err)
+            raise err
+          end
+        end
+
+        NO_ARGUMENTS = {}.freeze
+        def own_arguments
+          @own_arguments || NO_ARGUMENTS
+        end
+      end
+    end
+  end
+end