graphql 0.16.0 → 2.0.15

data/lib/graphql/schema/member.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'graphql/schema/member/base_dsl_methods'
+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'
+
+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 BaseDSLMethods
+      extend BaseDSLMethods::ConfigurationExtension
+      introspection(false)
+      extend TypeSystemHelpers
+      extend Scoped
+      extend RelayShortcuts
+      extend HasPath
+      extend HasAstNode
+      extend HasDirectives
+    end
+  end
+end
+
+require 'graphql/schema/member/has_arguments'
+require 'graphql/schema/member/has_fields'
+require 'graphql/schema/member/build_type'

data/lib/graphql/schema/mutation.rb

@@ -0,0 +1,85 @@
+# 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
+        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
+
+      # @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, max_errors: nil)
+        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, max_errors: max_errors)
+        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)
+        # `.validate_input` above is used for variables, but this method is used for arguments
+        if value.nil?
+          raise GraphQL::ExecutionError, "`null` is not a valid input for `#{to_type_signature}`, please provide a value for this argument."
+        end
+        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,117 @@
+# frozen_string_literal: true
+
+require "graphql/query/null_context"
+
+module GraphQL
+  class Schema
+    class Object < GraphQL::Schema::Member
+      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
+            begin
+              authorized?(object, context)
+            rescue GraphQL::UnauthorizedError => err
+              context.schema.unauthorized_object(err)
+            rescue StandardError => err
+              context.query.handle_or_reraise(err)
+            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 const_missing(name)
+          if name == :InvalidNullError
+            custom_err_class = GraphQL::InvalidNullError.subclass_for(self)
+            const_set(:InvalidNullError, custom_err_class)
+            custom_err_class
+          else
+            super
+          end
+        end
+
+        def kind
+          GraphQL::TypeKinds::OBJECT
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/printer.rb

@@ -1,156 +1,100 @@
+# frozen_string_literal: true
 module GraphQL
   class Schema
     # Used to convert your {GraphQL::Schema} to a GraphQL schema string
     #
+    # @example print your schema to standard output (via helper)
+    #   puts GraphQL::Schema::Printer.print_schema(MySchema)
+    #
     # @example print your schema to standard output
-    #   Schema = GraphQL::Schema.new(query: QueryType)
-    #   puts GraphQL::Schema::Printer.print_schema(Schema)
+    #   puts GraphQL::Schema::Printer.new(MySchema).print_schema
+    #
+    # @example print a single type to standard output
+    #   class Types::Query < GraphQL::Schema::Object
+    #     description "The query root of this schema"
+    #
+    #     field :post, Types::Post, null: true
+    #   end
+    #
+    #   class Types::Post < GraphQL::Schema::Object
+    #     description "A blog post"
     #
-    module Printer
-      extend self
+    #     field :id, ID, null: false
+    #     field :title, String, null: false
+    #     field :body, String, null: false
+    #   end
+    #
+    #   class MySchema < GraphQL::Schema
+    #     query(Types::Query)
+    #   end
+    #
+    #   printer = GraphQL::Schema::Printer.new(MySchema)
+    #   puts printer.print_type(Types::Post)
+    #
+    class Printer < GraphQL::Language::Printer
+      attr_reader :schema, :warden
 
-      # Return a GraphQL schema string for the defined types in the schema
       # @param schema [GraphQL::Schema]
-      def print_schema(schema)
-        print_filtered_schema(schema, method(:is_defined_type))
+      # @param context [Hash]
+      # @param only [<#call(member, ctx)>]
+      # @param except [<#call(member, ctx)>]
+      # @param introspection [Boolean] Should include the introspection types in the string?
+      def initialize(schema, context: nil, only: nil, except: nil, introspection: false)
+        @document_from_schema = GraphQL::Language::DocumentFromSchemaDefinition.new(
+          schema,
+          context: context,
+          only: only,
+          except: except,
+          include_introspection_types: introspection,
+        )
+
+        @document = @document_from_schema.document
+        @schema = schema
       end
 
       # Return the GraphQL schema string for the introspection type system
-      def print_introspection_schema
-        query_root = ObjectType.define do
-          name "Query"
+      def self.print_introspection_schema
+        query_root = Class.new(GraphQL::Schema::Object) do
+          graphql_name "Root"
+          field :throwaway_field, String
         end
-        schema = Schema.new(query: query_root)
-        print_filtered_schema(schema, method(:is_introspection_type))
-      end
+        schema = Class.new(GraphQL::Schema) { query(query_root) }
 
-      private
+        introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
+          schema,
+          except: ->(member, _) { member.graphql_name == "Root" },
+          include_introspection_types: true,
+          include_built_in_directives: true,
+        ).document
 
-      def print_filtered_schema(schema, type_filter)
-        types = schema.types.values.select{ |type| type_filter.call(type) }.sort_by(&:name)
-        types.map{ |type| print_type(type) }.join("\n\n")
+        introspection_schema_ast.to_query_string(printer: IntrospectionPrinter.new)
       end
 
-      BUILTIN_SCALARS = Set.new(["String", "Boolean", "Int", "Float", "ID"])
-      private_constant :BUILTIN_SCALARS
-
-      def is_introspection_type(type)
-        type.name.start_with?("__")
+      # Return a GraphQL schema string for the defined types in the schema
+      # @param schema [GraphQL::Schema]
+      # @param context [Hash]
+      # @param only [<#call(member, ctx)>]
+      # @param except [<#call(member, ctx)>]
+      def self.print_schema(schema, **args)
+        printer = new(schema, **args)
+        printer.print_schema
       end
 
-      def is_defined_type(type)
-        !is_introspection_type(type) && !BUILTIN_SCALARS.include?(type.name)
+      # Return a GraphQL schema string for the defined types in the schema
+      def print_schema
+        print(@document) + "\n"
       end
 
       def print_type(type)
-        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(type)
+        node = @document_from_schema.build_type_definition_node(type)
+        print(node)
       end
 
-      module TypeKindPrinters
-        module FieldPrinter
-          def print_fields(type)
-            type.all_fields.map{ |field| "  #{field.name}#{print_args(field)}: #{field.type}" }.join("\n")
-          end
-
-          def print_args(field)
-            return if field.arguments.empty?
-            "(#{field.arguments.values.map{ |arg| print_input_value(arg) }.join(", ")})"
-          end
-
-          def print_input_value(arg)
-            if arg.default_value.nil?
-              default_string = nil
-            else
-              default_string = " = #{print_value(arg.default_value, arg.type)}"
-            end
-
-            "#{arg.name}: #{arg.type.to_s}#{default_string}"
-          end
-
-          def print_value(value, type)
-            case type
-            when FLOAT_TYPE
-              value.to_f.inspect
-            when INT_TYPE
-              value.to_i.inspect
-            when BOOLEAN_TYPE
-              (!!value).inspect
-            when ScalarType, ID_TYPE, STRING_TYPE
-              value.to_s.inspect
-            when EnumType
-              value.to_s
-            when InputObjectType
-              fields = value.to_h.map{ |field_name, field_value|
-                field_type = type.input_fields.fetch(field_name.to_s).type
-                "#{field_name}: #{print_value(field_value, field_type)}"
-              }.join(", ")
-              "{ #{fields} }"
-            when NonNullType
-              print_value(value, type.of_type)
-            when ListType
-              "[#{value.to_a.map{ |v| print_value(v, type.of_type) }.join(", ")}]"
-            else
-              raise NotImplementedError, "Unexpected value type #{type.inspect}"
-            end
-          end
-        end
-
-        class ScalarPrinter
-          def self.print(type)
-            "scalar #{type.name}"
-          end
-        end
-
-        class ObjectPrinter
-          extend FieldPrinter
-          def self.print(type)
-            if type.interfaces.any?
-              implementations = " implements #{type.interfaces.map(&:to_s).join(", ")}"
-            else
-              implementations = nil
-            end
-            "type #{type.name}#{implementations} {\n#{print_fields(type)}\n}"
-          end
-        end
-
-        class InterfacePrinter
-          extend FieldPrinter
-          def self.print(type)
-            "interface #{type.name} {\n#{print_fields(type)}\n}"
-          end
+      class IntrospectionPrinter < GraphQL::Language::Printer
+        def print_schema_definition(schema)
+          "schema {\n  query: Root\n}"
         end
-
-        class UnionPrinter
-          def self.print(type)
-            "union #{type.name} = #{type.possible_types.map(&:to_s).join(" | ")}\n}"
-          end
-        end
-
-        class EnumPrinter
-          def self.print(type)
-            values = type.values.values.map{ |v| "  #{v.name}" }.join("\n")
-            "enum #{type.name} {\n#{values}\n}"
-          end
-        end
-
-        class InputObjectPrinter
-          extend FieldPrinter
-          def self.print(type)
-            fields = type.input_fields.values.map{ |field| "  #{print_input_value(field)}" }.join("\n")
-            "input #{type.name} {\n#{fields}\n}"
-          end
-        end
-
-        STRATEGIES = {
-          GraphQL::TypeKinds::SCALAR =>       ScalarPrinter,
-          GraphQL::TypeKinds::OBJECT =>       ObjectPrinter,
-          GraphQL::TypeKinds::INTERFACE =>    InterfacePrinter,
-          GraphQL::TypeKinds::UNION =>        UnionPrinter,
-          GraphQL::TypeKinds::ENUM =>         EnumPrinter,
-          GraphQL::TypeKinds::INPUT_OBJECT => InputObjectPrinter,
-        }
       end
-      private_constant :TypeKindPrinters
     end
   end
 end