graphql_cody 1.13.0

data/lib/graphql/schema/printer.rb

@@ -0,0 +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
+    #   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"
+    #
+    #     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
+
+      # @param schema [GraphQL::Schema]
+      # @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 self.print_introspection_schema
+        query_root = Class.new(GraphQL::Schema::Object) do
+          graphql_name "Root"
+          field :throwaway_field, String
+        end
+        schema = Class.new(GraphQL::Schema) { query(query_root) }
+
+        introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
+          schema,
+          except: ->(member, _) { member.graphql_name == "Root" },
+          include_introspection_types: true,
+          include_built_in_directives: true,
+        ).document
+
+        introspection_schema_ast.to_query_string(printer: IntrospectionPrinter.new)
+      end
+
+      # 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
+
+      # Return a GraphQL schema string for the defined types in the schema
+      def print_schema
+        print(@document) + "\n"
+      end
+
+      def print_type(type)
+        node = @document_from_schema.build_type_definition_node(type)
+        print(node)
+      end
+
+      class IntrospectionPrinter < GraphQL::Language::Printer
+        def print_schema_definition(schema)
+          "schema {\n  query: Root\n}"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+require "graphql/types/string"
+
+module GraphQL
+  class Schema
+    # Mutations that extend this base class get some conventions added for free:
+    #
+    # - An argument called `clientMutationId` is _always_ added, but it's not passed
+    #   to the resolve method. The value is re-inserted to the response. (It's for
+    #   client libraries to manage optimistic updates.)
+    # - The returned object type always has a field called `clientMutationId` to support that.
+    # - The mutation accepts one argument called `input`, `argument`s defined in the mutation
+    #   class are added to that input object, which is generated by the mutation.
+    #
+    # These conventions were first specified by Relay Classic, but they come in handy:
+    #
+    # - `clientMutationId` supports optimistic updates and cache rollbacks on the client
+    # - using a single `input:` argument makes it easy to post whole JSON objects to the mutation
+    #   using one GraphQL variable (`$input`) instead of making a separate variable for each argument.
+    #
+    # @see {GraphQL::Schema::Mutation} for an example, it's basically the same.
+    #
+    class RelayClassicMutation < GraphQL::Schema::Mutation
+      # The payload should always include this field
+      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
+      # Relay classic default:
+      null(true)
+
+      # Override {GraphQL::Schema::Resolver#resolve_with_support} to
+      # delete `client_mutation_id` from the kwargs.
+      def resolve_with_support(**inputs)
+        # Without the interpreter, the inputs are unwrapped by an instrumenter.
+        # But when using the interpreter, no instrumenters are applied.
+        if context.interpreter?
+          input = inputs[:input].to_kwargs
+
+          new_extras = field ? field.extras : []
+          all_extras = self.class.extras + new_extras
+
+          # Transfer these from the top-level hash to the
+          # shortcutted `input:` object
+          all_extras.each do |ext|
+            # It's possible that the `extra` was not passed along by this point,
+            # don't re-add it if it wasn't given here.
+            if inputs.key?(ext)
+              input[ext] = inputs[ext]
+            end
+          end
+        else
+          input = inputs
+        end
+
+        if input
+          # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+          input_kwargs = input.to_h
+          client_mutation_id = input_kwargs.delete(:client_mutation_id)
+        else
+          # Relay Classic Mutations with no `argument`s
+          # don't require `input:`
+          input_kwargs = {}
+        end
+
+        return_value = if input_kwargs.any?
+          super(**input_kwargs)
+        else
+          super()
+        end
+
+        # Again, this is done by an instrumenter when using non-interpreter execution.
+        if context.interpreter?
+          context.schema.after_lazy(return_value) do |return_hash|
+            # It might be an error
+            if return_hash.is_a?(Hash)
+              return_hash[:client_mutation_id] = client_mutation_id
+            end
+            return_hash
+          end
+        else
+          return_value
+        end
+      end
+
+      class << self
+
+        # Also apply this argument to the input type:
+        def argument(*args, **kwargs, &block)
+          it = input_type # make sure any inherited arguments are already added to it
+          arg = super
+
+          # This definition might be overriding something inherited;
+          # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
+          prev_args = it.own_arguments[arg.graphql_name]
+          case prev_args
+          when GraphQL::Schema::Argument
+            if prev_args.owner != self
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          when Array
+            prev_args.reject! { |a| a.owner != self }
+            if prev_args.empty?
+              it.own_arguments.delete(arg.graphql_name)
+            end
+          end
+
+          it.add_argument(arg)
+          arg
+        end
+
+        # The base class for generated input object types
+        # @param new_class [Class] The base class to use for generating input object definitions
+        # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
+        def input_object_class(new_class = nil)
+          if new_class
+            @input_object_class = new_class
+          end
+          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
+        end
+
+        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
+        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
+        def input_type(new_input_type = nil)
+          if new_input_type
+            @input_type = new_input_type
+          end
+          @input_type ||= generate_input_type
+        end
+
+        # Extend {Schema::Mutation.field_options} to add the `input` argument
+        def field_options
+          sig = super
+          # Arguments were added at the root, but they should be nested
+          sig[:arguments].clear
+          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
+          sig
+        end
+
+        private
+
+        # Generate the input type for the `input:` argument
+        # To customize how input objects are generated, override this method
+        # @return [Class] a subclass of {.input_object_class}
+        def generate_input_type
+          mutation_args = all_argument_definitions
+          mutation_name = graphql_name
+          mutation_class = self
+          Class.new(input_object_class) do
+            graphql_name("#{mutation_name}Input")
+            description("Autogenerated input type of #{mutation_name}")
+            mutation(mutation_class)
+            # these might be inherited:
+            mutation_args.each do |arg|
+              add_argument(arg)
+            end
+            argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/rescue_middleware.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # - Store a table of errors & handlers
+    # - Rescue errors in a middleware chain, then check for a handler
+    # - If a handler is found, use it & return a {GraphQL::ExecutionError}
+    # - If no handler is found, re-raise the error
+    class RescueMiddleware
+      # @return [Hash] `{class => proc}` pairs for handling errors
+      attr_reader :rescue_table
+      def initialize
+        @rescue_table = {}
+      end
+
+      # @example Rescue from not-found by telling the user
+      #   MySchema.rescue_from(ActiveRecord::RecordNotFound) { "An item could not be found" }
+      #
+      # @param error_classes [Class] one or more classes of errors to rescue from
+      # @yield [err] A handler to return a message for these error instances
+      # @yieldparam [Exception] an error that was rescued
+      # @yieldreturn [String] message to put in GraphQL response
+      def rescue_from(*error_classes, &block)
+        error_classes.map{ |error_class| rescue_table[error_class] = block }
+      end
+
+      # Remove the handler for `error_classs`
+      # @param error_class [Class] the error class whose handler should be removed
+      def remove_handler(*error_classes)
+        error_classes.map{ |error_class| rescue_table.delete(error_class) }
+      end
+
+      # Implement the requirement for {GraphQL::Schema::MiddlewareChain}
+      def call(*args)
+        begin
+          yield
+        rescue StandardError => err
+          attempt_rescue(err)
+        end
+      end
+
+      private
+
+      def attempt_rescue(err)
+        rescue_table.each { |klass, handler|
+          if klass.is_a?(Class) && err.is_a?(klass) && handler
+            result = handler.call(err)
+            case result
+            when String
+              return GraphQL::ExecutionError.new(result)
+            when GraphQL::ExecutionError
+              return result
+            end
+          end
+        }
+
+        raise(err)
+      end
+    end
+  end
+end

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Resolver
+      # Adds `field(...)` helper to resolvers so that they can
+      # generate payload types.
+      #
+      # Or, an already-defined one can be attached with `payload_type(...)`.
+      module HasPayloadType
+        # Call this method to get the derived return type of the mutation,
+        # or use it as a configuration method to assign a return type
+        # instead of generating one.
+        # @param new_payload_type [Class, nil] If a type definition class is provided, it will be used as the return type of the mutation field
+        # @return [Class] The object type which this mutation returns.
+        def payload_type(new_payload_type = nil)
+          if new_payload_type
+            @payload_type = new_payload_type
+          end
+          @payload_type ||= generate_payload_type
+        end
+
+        alias :type :payload_type
+        alias :type_expr :payload_type
+
+        def field_class(new_class = nil)
+          if new_class
+            @field_class = new_class
+          elsif defined?(@field_class) && @field_class
+            @field_class
+          else
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
+          end
+        end
+
+        # An object class to use for deriving return types
+        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
+        # @return [Class]
+        def object_class(new_class = nil)
+          if new_class
+            if defined?(@payload_type)
+              raise "Can't configure `object_class(...)` after the payload type has already been initialized. Move this configuration higher up the class definition."
+            end
+            @object_class = new_class
+          else
+            @object_class || find_inherited_value(:object_class, GraphQL::Schema::Object)
+          end
+        end
+
+        NO_INTERFACES = [].freeze
+
+        def field(*args, **kwargs, &block)
+          pt = payload_type # make sure it's initialized with any inherited fields
+          field_defn = super
+
+          # Remove any inherited fields to avoid false conflicts at runtime
+          prev_fields = pt.own_fields[field_defn.graphql_name]
+          case prev_fields
+          when GraphQL::Schema::Field
+            if prev_fields.owner != self
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
+          when Array
+            prev_fields.reject! { |f| f.owner != self }
+            if prev_fields.empty?
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
+          end
+
+          pt.add_field(field_defn, method_conflict_warning: false)
+          field_defn
+        end
+
+        private
+
+        # Build a subclass of {.object_class} based on `self`.
+        # This value will be cached as `{.payload_type}`.
+        # Override this hook to customize return type generation.
+        def generate_payload_type
+          resolver_name = graphql_name
+          resolver_fields = all_field_definitions
+          Class.new(object_class) do
+            graphql_name("#{resolver_name}Payload")
+            description("Autogenerated return type of #{resolver_name}")
+            resolver_fields.each do |f|
+              # Reattach the already-defined field here
+              # (The field's `.owner` will still point to the mutation, not the object type, I think)
+              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+              add_field(f, method_conflict_warning: false)
+            end
+          end
+        end
+      end
+    end
+  end
+end