graphql 0.16.0 → 2.0.15

data/lib/graphql/schema/interface.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module Interface
+      include GraphQL::Schema::Member::GraphQLTypeNames
+      module DefinitionMethods
+        include GraphQL::Schema::Member::BaseDSLMethods
+        # ConfigurationExtension's responsibilities are in `def included` below
+        include GraphQL::Schema::Member::TypeSystemHelpers
+        include GraphQL::Schema::Member::HasFields
+        include GraphQL::Schema::Member::HasPath
+        include GraphQL::Schema::Member::RelayShortcuts
+        include GraphQL::Schema::Member::Scoped
+        include GraphQL::Schema::Member::HasAstNode
+        include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDirectives
+        include GraphQL::Schema::Member::HasInterfaces
+
+        # Methods defined in this block will be:
+        # - Added as class methods to this interface
+        # - Added as class methods to all child interfaces
+        def definition_methods(&block)
+          self::DefinitionMethods.module_eval(&block)
+        end
+
+        # @see {Schema::Warden} hides interfaces without visible implementations
+        def visible?(context)
+          true
+        end
+
+        # The interface is accessible if any of its possible types are accessible
+        def accessible?(context)
+          context.schema.possible_types(self, context).each do |type|
+            if context.schema.accessible?(type, context)
+              return true
+            end
+          end
+          false
+        end
+
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
+          end
+        end
+
+        # Here's the tricky part. Make sure behavior keeps making its way down the inheritance chain.
+        def included(child_class)
+          if !child_class.is_a?(Class)
+            # In this case, it's been included into another interface.
+            # This is how interface inheritance is implemented
+
+            # We need this before we can call `own_interfaces`
+            child_class.extend(Schema::Interface::DefinitionMethods)
+
+            child_class.type_membership_class(self.type_membership_class)
+            child_class.ancestors.reverse_each do |ancestor|
+              if ancestor.const_defined?(:DefinitionMethods)
+                child_class.extend(ancestor::DefinitionMethods)
+              end
+            end
+
+            # Use an instance variable to tell whether it's been included previously or not;
+            # You can't use constant detection because constants are brought into scope
+            # by `include`, which has already happened at this point.
+            if !child_class.instance_variable_defined?(:@_definition_methods)
+              defn_methods_module = Module.new
+              child_class.instance_variable_set(:@_definition_methods, defn_methods_module)
+              child_class.const_set(:DefinitionMethods, defn_methods_module)
+              child_class.extend(child_class::DefinitionMethods)
+            end
+            child_class.introspection(introspection)
+            child_class.description(description)
+            # If interfaces are mixed into each other, only define this class once
+            if !child_class.const_defined?(:UnresolvedTypeError, false)
+              add_unresolved_type_error(child_class)
+            end
+          elsif child_class < GraphQL::Schema::Object
+            # This is being included into an object type, make sure it's using `implements(...)`
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
+            if !backtrace_line
+              raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
+            end
+          end
+
+          super
+        end
+
+        def orphan_types(*types)
+          if types.any?
+            @orphan_types = types
+          else
+            all_orphan_types = @orphan_types || []
+            all_orphan_types += super if defined?(super)
+            all_orphan_types.uniq
+          end
+        end
+
+        def kind
+          GraphQL::TypeKinds::INTERFACE
+        end
+      end
+
+      extend DefinitionMethods
+
+      def unwrap
+        self
+      end
+    end
+  end
+end

data/lib/graphql/schema/introspection_system.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class IntrospectionSystem
+      attr_reader :types, :possible_types
+
+      def initialize(schema)
+        @schema = schema
+        @class_based = !!@schema.is_a?(Class)
+        @built_in_namespace = GraphQL::Introspection
+        @custom_namespace = if @class_based
+          schema.introspection || @built_in_namespace
+        else
+          schema.introspection_namespace || @built_in_namespace
+        end
+
+        type_defns = [
+          load_constant(:SchemaType),
+          load_constant(:TypeType),
+          load_constant(:FieldType),
+          load_constant(:DirectiveType),
+          load_constant(:EnumValueType),
+          load_constant(:InputValueType),
+          load_constant(:TypeKindEnum),
+          load_constant(:DirectiveLocationEnum)
+        ]
+        @types = {}
+        @possible_types = {}
+        type_defns.each do |t|
+          @types[t.graphql_name] = t
+          @possible_types[t.graphql_name] = [t]
+        end
+        @entry_point_fields =
+          if schema.disable_introspection_entry_points?
+            {}
+          else
+            entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields.delete('__schema') if schema.disable_schema_introspection_entry_point?
+            entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point?
+            entry_point_fields
+          end
+        @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+      end
+
+      def entry_points
+        @entry_point_fields.values
+      end
+
+      def entry_point(name:)
+        @entry_point_fields[name]
+      end
+
+      def dynamic_fields
+        @dynamic_fields.values
+      end
+
+      def dynamic_field(name:)
+        @dynamic_fields[name]
+      end
+
+      # The introspection system is prepared with a bunch of LateBoundTypes.
+      # Replace those with the objects that they refer to, since LateBoundTypes
+      # aren't handled at runtime.
+      #
+      # @api private
+      # @return void
+      def resolve_late_bindings
+        @types.each do |name, t|
+          if t.kind.fields?
+            t.fields.each do |_name, field_defn|
+              field_defn.type = resolve_late_binding(field_defn.type)
+            end
+          end
+        end
+
+        @entry_point_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+
+        @dynamic_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+        nil
+      end
+
+      private
+
+      def resolve_late_binding(late_bound_type)
+        case late_bound_type
+        when GraphQL::Schema::LateBoundType
+          @schema.get_type(late_bound_type.name)
+        when GraphQL::Schema::List
+          resolve_late_binding(late_bound_type.of_type).to_list_type
+        when GraphQL::Schema::NonNull
+          resolve_late_binding(late_bound_type.of_type).to_non_null_type
+        when Module
+          # It's a normal type -- no change required
+          late_bound_type
+        else
+          raise "Invariant: unexpected type: #{late_bound_type} (#{late_bound_type.class})"
+        end
+      end
+
+      def load_constant(class_name)
+        const = @custom_namespace.const_get(class_name)
+        dup_type_class(const)
+      rescue NameError
+        # Dup the built-in so that the cached fields aren't shared
+        dup_type_class(@built_in_namespace.const_get(class_name))
+      end
+
+      def get_fields_from_class(class_sym:)
+        object_type_defn = load_constant(class_sym)
+
+        if object_type_defn.is_a?(Module)
+          object_type_defn.fields
+        else
+          extracted_field_defns = {}
+          object_class = object_type_defn.metadata[:type_class]
+          object_type_defn.all_fields.each do |field_defn|
+            inner_resolve = field_defn.resolve_proc
+            resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
+            extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
+          end
+          extracted_field_defns
+        end
+      end
+
+      # This is probably not 100% robust -- but it has to be good enough to avoid modifying the built-in introspection types
+      def dup_type_class(type_class)
+        type_name = type_class.graphql_name
+        Class.new(type_class) do
+          # This won't be inherited like other things will
+          graphql_name(type_name)
+
+          if type_class.kind.fields?
+            type_class.fields.each do |_name, field_defn|
+              dup_field = field_defn.dup
+              dup_field.owner = self
+              add_field(dup_field)
+            end
+          end
+        end
+      end
+
+      class PerFieldProxyResolve
+        def initialize(object_class:, inner_resolve:)
+          @object_class = object_class
+          @inner_resolve = inner_resolve
+        end
+
+        def call(obj, args, ctx)
+          query_ctx = ctx.query.context
+          # Remove the QueryType wrapper
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          wrapped_object = @object_class.authorized_new(obj, query_ctx)
+          @inner_resolve.call(wrapped_object, args, ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/invalid_type_error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class Schema
     class InvalidTypeError < GraphQL::Error

data/lib/graphql/schema/late_bound_type.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # A stand-in for a type which will be resolved in a given schema, by name.
+    # TODO: support argument types too, make this a public API somehow
+    # @api Private
+    class LateBoundType
+      attr_reader :name
+      alias :graphql_name :name
+      def initialize(local_name)
+        @name = local_name
+      end
+
+      def unwrap
+        self
+      end
+
+      def to_non_null_type
+        @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
+      end
+
+      def to_list_type
+        @to_list_type ||= GraphQL::Schema::List.new(self)
+      end
+
+      def inspect
+        "#<LateBoundType @name=#{name}>"
+      end
+
+      def non_null?
+        false
+      end
+
+      alias :to_s :inspect
+    end
+  end
+end

data/lib/graphql/schema/list.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Represents a list type in the schema.
+    # Wraps a {Schema::Member} as a list type.
+    # @see {Schema::Member::TypeSystemHelpers#to_list_type}
+    class List < GraphQL::Schema::Wrapper
+      include Schema::Member::ValidatesInput
+
+      # @return [GraphQL::TypeKinds::LIST]
+      def kind
+        GraphQL::TypeKinds::LIST
+      end
+
+      # @return [true]
+      def list?
+        true
+      end
+
+      def to_type_signature
+        "[#{@of_type.to_type_signature}]"
+      end
+
+      # This is for introspection, where it's expected the name will be `null`
+      def graphql_name
+        nil
+      end
+
+      # Also for implementing introspection
+      def description
+        nil
+      end
+
+      def coerce_result(value, ctx)
+        value.map { |i| i.nil? ? nil : of_type.coerce_result(i, ctx) }
+      end
+
+      def coerce_input(value, ctx)
+        if value.nil?
+          nil
+        else
+          coerced = ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          ctx.schema.after_any_lazies(coerced, &:itself)
+        end
+      end
+
+      def validate_non_null_input(value, ctx, max_errors: nil)
+        result = GraphQL::Query::InputValidationResult.new
+        ensure_array(value).each_with_index do |item, index|
+          item_result = of_type.validate_input(item, ctx)
+          unless item_result.valid?
+            if max_errors
+              if max_errors == 0
+                add_max_errros_reached_message(result)
+                break
+              end
+
+              max_errors -= 1
+            end
+
+            result.merge_result!(index, item_result)
+          end
+        end
+        result.valid? ? nil : result
+      end
+
+      private
+
+      def ensure_array(value)
+        # `Array({ a: 1 })` makes `[[:a, 1]]`, so do it manually
+        if value.is_a?(Array)
+          value
+        else
+          [value]
+        end
+      end
+
+      def add_max_errros_reached_message(result)
+        message = "Too many errors processing list variable, max validation error limit reached. Execution aborted"
+        item_result = GraphQL::Query::InputValidationResult.from_problem(message)
+        result.merge_result!(nil, item_result)
+      end
+    end
+  end
+end

data/lib/graphql/schema/loader.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # You can use the result of {GraphQL::Introspection::INTROSPECTION_QUERY}
+    # to make a schema. This schema is missing some important details like
+    # `resolve` functions, but it does include the full type system,
+    # so you can use it to validate queries.
+    #
+    # @see GraphQL::Schema.from_introspection for a public API
+    module Loader
+      extend self
+
+      # Create schema with the result of an introspection query.
+      # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
+      # @return [Class] the schema described by `input`
+      def load(introspection_result)
+        schema = introspection_result.fetch("data").fetch("__schema")
+
+        types = {}
+        type_resolver = ->(type) { resolve_type(types, type) }
+
+        schema.fetch("types").each do |type|
+          next if type.fetch("name").start_with?("__")
+          type_object = define_type(type, type_resolver)
+          types[type["name"]] = type_object
+        end
+
+        directives = []
+        schema.fetch("directives", []).each do |directive|
+          next if GraphQL::Schema.default_directives.include?(directive.fetch("name"))
+          directives << define_directive(directive, type_resolver)
+        end
+
+        Class.new(GraphQL::Schema) do
+          orphan_types(types.values)
+          directives(directives)
+          description(schema["description"])
+
+          def self.resolve_type(*)
+            raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
+          end
+
+          [:query, :mutation, :subscription].each do |root|
+            type = schema["#{root}Type"]
+            if type
+              type_defn = types.fetch(type.fetch("name"))
+              self.public_send(root, type_defn)
+            end
+          end
+        end
+      end
+
+      NullScalarCoerce = ->(val, _ctx) { val }
+
+      class << self
+        private
+
+        def resolve_type(types, type)
+          case kind = type.fetch("kind")
+          when "ENUM", "INTERFACE", "INPUT_OBJECT", "OBJECT", "SCALAR", "UNION"
+            type_name = type.fetch("name")
+            type = types[type_name] || Schema::BUILT_IN_TYPES[type_name]
+            if type.nil?
+              GraphQL::Schema::LateBoundType.new(type_name)
+            else
+              type
+            end
+          when "LIST"
+            Schema::List.new(resolve_type(types, type.fetch("ofType")))
+          when "NON_NULL"
+            Schema::NonNull.new(resolve_type(types, type.fetch("ofType")))
+          else
+            fail GraphQL::RequiredImplementationMissingError, "#{kind} not implemented"
+          end
+        end
+
+        def extract_default_value(default_value_str, input_value_ast)
+          case input_value_ast
+          when String, Integer, Float, TrueClass, FalseClass
+            input_value_ast
+          when GraphQL::Language::Nodes::Enum
+            input_value_ast.name
+          when GraphQL::Language::Nodes::NullValue
+            nil
+          when GraphQL::Language::Nodes::InputObject
+            input_value_ast.to_h
+          when Array
+            input_value_ast.map { |element| extract_default_value(default_value_str, element) }
+          else
+            raise(
+              "Encountered unexpected type when loading default value. "\
+                    "input_value_ast.class is #{input_value_ast.class} "\
+                    "default_value is #{default_value_str}"
+            )
+          end
+        end
+
+        def define_type(type, type_resolver)
+          loader = self
+          case type.fetch("kind")
+          when "ENUM"
+            Class.new(GraphQL::Schema::Enum) do
+              graphql_name(type["name"])
+              description(type["description"])
+              type["enumValues"].each do |enum_value|
+                value(
+                  enum_value["name"],
+                  description: enum_value["description"],
+                  deprecation_reason: enum_value["deprecationReason"],
+                )
+              end
+            end
+          when "INTERFACE"
+            Module.new do
+              include GraphQL::Schema::Interface
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_fields(self, type["fields"] || [], type_resolver)
+            end
+          when "INPUT_OBJECT"
+            Class.new(GraphQL::Schema::InputObject) do
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_arguments(self, type["inputFields"], type_resolver)
+            end
+          when "OBJECT"
+            Class.new(GraphQL::Schema::Object) do
+              graphql_name(type["name"])
+              description(type["description"])
+              if type["interfaces"]
+                type["interfaces"].each do |interface_type|
+                  implements(type_resolver.call(interface_type))
+                end
+              end
+              loader.build_fields(self, type["fields"], type_resolver)
+            end
+          when "SCALAR"
+            type_name = type.fetch("name")
+            if (builtin = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+              builtin
+            else
+              Class.new(GraphQL::Schema::Scalar) do
+                graphql_name(type["name"])
+                description(type["description"])
+                specified_by_url(type["specifiedByURL"])
+              end
+            end
+          when "UNION"
+            Class.new(GraphQL::Schema::Union) do
+              graphql_name(type["name"])
+              description(type["description"])
+              possible_types(*(type["possibleTypes"].map { |pt| type_resolver.call(pt) }))
+            end
+          else
+            fail GraphQL::RequiredImplementationMissingError, "#{type["kind"]} not implemented"
+          end
+        end
+
+        def define_directive(directive, type_resolver)
+          loader = self
+          Class.new(GraphQL::Schema::Directive) do
+            graphql_name(directive["name"])
+            description(directive["description"])
+            locations(*directive["locations"].map(&:to_sym))
+            repeatable(directive["isRepeatable"])
+            loader.build_arguments(self, directive["args"], type_resolver)
+          end
+        end
+
+        public
+
+        def build_fields(type_defn, fields, type_resolver)
+          loader = self
+          fields.each do |field_hash|
+            unwrapped_field_hash = field_hash
+            while (of_type = unwrapped_field_hash["ofType"])
+              unwrapped_field_hash = of_type
+            end
+            type_name = unwrapped_field_hash["name"]
+
+            type_defn.field(
+              field_hash["name"],
+              type: type_resolver.call(field_hash["type"]),
+              description: field_hash["description"],
+              deprecation_reason: field_hash["deprecationReason"],
+              null: true,
+              camelize: false,
+              connection_extension: nil,
+              connection: type_name.end_with?("Connection"),
+            ) do
+              if field_hash["args"].any?
+                loader.build_arguments(self, field_hash["args"], type_resolver)
+              end
+            end
+          end
+        end
+
+        def build_arguments(arg_owner, args, type_resolver)
+          args.each do |arg|
+            kwargs = {
+              type: type_resolver.call(arg["type"]),
+              description: arg["description"],
+              deprecation_reason: arg["deprecationReason"],
+              required: false,
+              camelize: false,
+            }
+
+            if arg["defaultValue"]
+              default_value_str = arg["defaultValue"]
+
+              dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
+
+              # Returns a `GraphQL::Language::Nodes::Document`:
+              dummy_query_ast = GraphQL.parse(dummy_query_str)
+
+              # Reach into the AST for the default value:
+              input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
+
+              kwargs[:default_value] = extract_default_value(default_value_str, input_value_ast)
+            end
+
+            arg_owner.argument(arg["name"], **kwargs)
+          end
+        end
+      end
+    end
+  end
+end