graphql_cody 1.13.0

data/lib/generators/graphql/templates/base_interface.erb

@@ -0,0 +1,9 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  module BaseInterface
+    include GraphQL::Schema::Interface
+
+    field_class Types::BaseField
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/base_mutation.erb

@@ -0,0 +1,10 @@
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class BaseMutation < GraphQL::Schema::RelayClassicMutation
+    argument_class Types::BaseArgument
+    field_class Types::BaseField
+    input_object_class Types::BaseInputObject
+    object_class Types::BaseObject
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/base_object.erb

@@ -0,0 +1,7 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseObject < GraphQL::Schema::Object
+    field_class Types::BaseField
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/base_scalar.erb

@@ -0,0 +1,6 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseScalar < GraphQL::Schema::Scalar
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/base_union.erb

@@ -0,0 +1,6 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseUnion < GraphQL::Schema::Union
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/enum.erb

@@ -0,0 +1,7 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseEnum
+<% prepared_values.each do |v| %>    value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
+<% end %>  end
+end
+<% end -%>

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -0,0 +1,52 @@
+<% module_namespacing_when_supported do -%>
+class GraphqlController < ApplicationController
+  # If accessing from outside this domain, nullify the session
+  # This allows for outside API access while preventing CSRF attacks,
+  # but you'll have to authenticate your user separately
+  # protect_from_forgery with: :null_session
+
+  def execute
+    variables = prepare_variables(params[:variables])
+    query = params[:query]
+    operation_name = params[:operationName]
+    context = {
+      # Query context goes here, for example:
+      # current_user: current_user,
+    }
+    result = <%= schema_name %>.execute(query, variables: variables, context: context, operation_name: operation_name)
+    render json: result
+  rescue StandardError => e
+    raise e unless Rails.env.development?
+    handle_error_in_development(e)
+  end
+
+  private
+
+  # Handle variables in form data, JSON body, or a blank value
+  def prepare_variables(variables_param)
+    case variables_param
+    when String
+      if variables_param.present?
+        JSON.parse(variables_param) || {}
+      else
+        {}
+      end
+    when Hash
+      variables_param
+    when ActionController::Parameters
+      variables_param.to_unsafe_hash # GraphQL-Ruby will validate name and type of incoming variables.
+    when nil
+      {}
+    else
+      raise ArgumentError, "Unexpected parameter: #{variables_param}"
+    end
+  end
+
+  def handle_error_in_development(e)
+    logger.error e.message
+    logger.error e.backtrace.join("\n")
+
+    render json: { errors: [{ message: e.message, backtrace: e.backtrace }], data: {} }, status: 500
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/interface.erb

@@ -0,0 +1,8 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  module <%= type_ruby_name.split('::')[-1] %>
+    include Types::BaseInterface
+<% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+<% end %>  end
+end
+<% end -%>

data/lib/generators/graphql/templates/loader.erb

@@ -0,0 +1,19 @@
+<% module_namespacing_when_supported do -%>
+module Loaders
+  class <%= class_name %> < GraphQL::Batch::Loader
+    # Define `initialize` to store grouping arguments, eg
+    #
+    #     Loaders::<%= class_name %>.for(group).load(value)
+    #
+    # def initialize()
+    # end
+
+    # `keys` contains each key from `.load(key)`.
+    # Find the corresponding values, then
+    # call `fulfill(key, value)` or `fulfill(key, nil)`
+    # for each key.
+    def perform(keys)
+    end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/mutation.erb

@@ -0,0 +1,16 @@
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= mutation_name %> < BaseMutation
+    # TODO: define return fields
+    # field :post, Types::PostType, null: false
+
+    # TODO: define arguments
+    # argument :name, String, required: true
+
+    # TODO: define resolve method
+    # def resolve(name:)
+    #   { post: ... }
+    # end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/mutation_type.erb

@@ -0,0 +1,12 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class MutationType < Types::BaseObject
+    # TODO: remove me
+    field :test_field, String, null: false,
+      description: "An example field added by the generator"
+    def test_field
+      "Hello World"
+    end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/node_type.erb

@@ -0,0 +1,9 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  module NodeType
+    include Types::BaseInterface
+    # Add the `id` field
+    include GraphQL::Types::Relay::NodeBehaviors
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/object.erb

@@ -0,0 +1,8 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
+<% if options.node %>    implements GraphQL::Types::Relay::Node
+<% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+<% end %>  end
+end
+<% end -%>

data/lib/generators/graphql/templates/query_type.erb

@@ -0,0 +1,15 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class QueryType < Types::BaseObject
+    # Add root-level fields here.
+    # They will be entry points for queries on your schema.
+
+    # TODO: remove me
+    field :test_field, String, null: false,
+      description: "An example field added by the generator"
+    def test_field
+      "Hello World!"
+    end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/scalar.erb

@@ -0,0 +1,15 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseScalar
+    def self.coerce_input(input_value, context)
+      # Override this to prepare a client-provided GraphQL value for your Ruby code
+      input_value
+    end
+
+    def self.coerce_result(ruby_value, context)
+      # Override this to serialize a Ruby value for the GraphQL response
+      ruby_value.to_s
+    end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/schema.erb

@@ -0,0 +1,27 @@
+<% module_namespacing_when_supported do -%>
+class <%= schema_name %> < GraphQL::Schema
+  query(Types::QueryType)
+<% if options[:batch] %>
+  # GraphQL::Batch setup:
+  use GraphQL::Batch
+<% else %>
+  # For batch-loading (see https://graphql-ruby.org/dataloader/overview.html)
+  use GraphQL::Dataloader
+<% end %>
+  # GraphQL-Ruby calls this when something goes wrong while running a query:
+  def self.type_error(err, context)
+    # if err.is_a?(GraphQL::InvalidNullError)
+    #   # report to your bug tracker here
+    #   return nil
+    # end
+    super
+  end
+
+  # Union and Interface Resolution
+  def self.resolve_type(abstract_type, obj, ctx)
+    # TODO: Implement this method
+    # to return the correct GraphQL object type for `obj`
+    raise(GraphQL::RequiredImplementationMissingError)
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/union.erb

@@ -0,0 +1,7 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseUnion
+<% if possible_types.any? %>    possible_types <%= normalized_possible_types.join(", ") %>
+<% end %>  end
+end
+<% end -%>

data/lib/generators/graphql/type_generator.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'rails/generators'
+require 'rails/generators/base'
+require 'graphql'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require_relative 'core'
+
+module Graphql
+  module Generators
+    class TypeGeneratorBase < Rails::Generators::Base
+      include Core
+
+      argument :type_name,
+        type: :string,
+        banner: "TypeName",
+        desc: "Name of this object type (expressed as Ruby or GraphQL)"
+
+      # Take a type expression in any combination of GraphQL or Ruby styles
+      # and return it in a specified output style
+      # TODO: nullability / list with `mode: :graphql` doesn't work
+      # @param type_expresson [String]
+      # @param mode [Symbol]
+      # @param null [Boolean]
+      # @return [(String, Boolean)] The type expression, followed by `null:` value
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        if type_expression.start_with?("!")
+          normalize_type_expression(type_expression[1..-1], mode: mode, null: false)
+        elsif type_expression.end_with?("!")
+          normalize_type_expression(type_expression[0..-2], mode: mode, null: false)
+        elsif type_expression.start_with?("[") && type_expression.end_with?("]")
+          name, is_null = normalize_type_expression(type_expression[1..-2], mode: mode, null: null)
+          ["[#{name}]", is_null]
+        elsif type_expression.end_with?("Type")
+          normalize_type_expression(type_expression[0..-5], mode: mode, null: null)
+        elsif type_expression.start_with?("Types::")
+          normalize_type_expression(type_expression[7..-1], mode: mode, null: null)
+        elsif type_expression.start_with?("types.")
+          normalize_type_expression(type_expression[6..-1], mode: mode, null: null)
+        else
+          case mode
+          when :ruby
+            case type_expression
+            when "Int"
+              ["Integer", null]
+            when "Integer", "Float", "Boolean", "String", "ID"
+              [type_expression, null]
+            else
+              ["Types::#{type_expression.camelize}Type", null]
+            end
+          when :graphql
+            [type_expression.camelize, null]
+          else
+            raise "Unexpected normalize mode: #{mode}"
+          end
+        end
+      end
+
+      private
+
+      # @return [String] The user-provided type name, normalized to Ruby code
+      def type_ruby_name
+        @type_ruby_name ||= self.class.normalize_type_expression(type_name, mode: :ruby)[0]
+      end
+
+      # @return [String] The user-provided type name, as a GraphQL name
+      def type_graphql_name
+        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
+      end
+
+      # @return [String] The user-provided type name, as a file name (without extension)
+      def type_file_name
+        @type_file_name ||= "#{type_graphql_name}Type".underscore
+      end
+
+      # @return [Array<NormalizedField>] User-provided fields, in `(name, Ruby type name)` pairs
+      def normalized_fields
+        @normalized_fields ||= fields.map { |f|
+          name, raw_type = f.split(":", 2)
+          type_expr, null = self.class.normalize_type_expression(raw_type, mode: :ruby)
+          NormalizedField.new(name, type_expr, null)
+        }
+      end
+
+      class NormalizedField
+        def initialize(name, type_expr, null)
+          @name = name
+          @type_expr = type_expr
+          @null = null
+        end
+
+        def to_ruby
+          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/union_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'generators/graphql/type_generator'
+
+module Graphql
+  module Generators
+    # Generate a union type by name
+    # with the specified member types.
+    #
+    # ```
+    # rails g graphql:union SearchResultType ImageType AudioType
+    # ```
+    class UnionGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::UnionType with the given name and possible types"
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :possible_types,
+        type: :array,
+        default: [],
+        banner: "type type ...",
+        desc: "Possible types for this union (expressed as Ruby or GraphQL)"
+
+      def create_type_file
+        template "union.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
+      end
+
+      private
+
+      def normalized_possible_types
+        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
+      end
+    end
+  end
+end

data/lib/graphql/analysis/analyze_query.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module_function
+
+    def use(schema_class)
+      schema = schema_class.is_a?(Class) ? schema_class : schema_class.target
+      schema.analysis_engine = self
+    end
+
+    # @return [void]
+    def analyze_multiplex(multiplex, analyzers)
+      multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
+        reducer_states = analyzers.map { |r| ReducerState.new(r, multiplex) }
+        query_results = multiplex.queries.map do |query|
+          if query.valid?
+            analyze_query(query, query.analyzers, multiplex_states: reducer_states)
+          else
+            []
+          end
+        end
+
+        multiplex_results = reducer_states.map(&:finalize_reducer)
+        multiplex_errors = analysis_errors(multiplex_results)
+
+        multiplex.queries.each_with_index do |query, idx|
+          query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
+        end
+      end
+      nil
+    end
+
+    # Visit `query`'s internal representation, calling `analyzers` along the way.
+    #
+    # - First, query analyzers are filtered down by calling `.analyze?(query)`, if they respond to that method
+    # - Then, query analyzers are initialized by calling `.initial_value(query)`, if they respond to that method.
+    # - Then, they receive `.call(memo, visit_type, irep_node)`, where visit type is `:enter` or `:leave`.
+    # - Last, they receive `.final_value(memo)`, if they respond to that method.
+    #
+    # It returns an array of final `memo` values in the order that `analyzers` were passed in.
+    #
+    # @param query [GraphQL::Query]
+    # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
+    # @return [Array<Any>] Results from those analyzers
+    def analyze_query(query, analyzers, multiplex_states: [])
+      GraphQL::Deprecation.warn "Legacy analysis will be removed in GraphQL-Ruby 2.0, please upgrade to AST Analysis: https://graphql-ruby.org/queries/ast_analysis.html (schema: #{query.schema})"
+
+      query.trace("analyze_query", { query: query }) do
+        analyzers_to_run = analyzers.select do |analyzer|
+          if analyzer.respond_to?(:analyze?)
+            analyzer.analyze?(query)
+          else
+            true
+          end
+        end
+
+        reducer_states = analyzers_to_run.map { |r| ReducerState.new(r, query) } + multiplex_states
+
+        irep = query.internal_representation
+
+        irep.operation_definitions.each do |name, op_node|
+          reduce_node(op_node, reducer_states)
+        end
+
+        reducer_states.map(&:finalize_reducer)
+      end
+    end
+
+    private
+
+    module_function
+
+    # Enter the node, visit its children, then leave the node.
+    def reduce_node(irep_node, reducer_states)
+      visit_analyzers(:enter, irep_node, reducer_states)
+
+      irep_node.typed_children.each do |type_defn, children|
+        children.each do |name, child_irep_node|
+          reduce_node(child_irep_node, reducer_states)
+        end
+      end
+
+      visit_analyzers(:leave, irep_node, reducer_states)
+    end
+
+    def visit_analyzers(visit_type, irep_node, reducer_states)
+      reducer_states.each do |reducer_state|
+        next_memo = reducer_state.call(visit_type, irep_node)
+
+        reducer_state.memo = next_memo
+      end
+    end
+
+    def analysis_errors(results)
+      results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
+    end
+  end
+end

data/lib/graphql/analysis/ast/analyzer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      # Query analyzer for query ASTs. Query analyzers respond to visitor style methods
+      # but are prefixed by `enter` and `leave`.
+      #
+      # When an analyzer is initialized with a Multiplex, you can always get the current query from
+      # `visitor.query` in the visit methods.
+      #
+      # @param [GraphQL::Query, GraphQL::Execution::Multiplex] The query or multiplex to analyze
+      class Analyzer
+        def initialize(subject)
+          @subject = subject
+
+          if subject.is_a?(GraphQL::Query)
+            @query = subject
+            @multiplex = nil
+          else
+            @multiplex = subject
+            @query = nil
+          end
+        end
+
+        # Analyzer hook to decide at analysis time whether a query should
+        # be analyzed or not.
+        # @return [Boolean] If the query should be analyzed or not
+        def analyze?
+          true
+        end
+
+        # The result for this analyzer. Returning {GraphQL::AnalysisError} results
+        # in a query error.
+        # @return [Any] The analyzer result
+        def result
+          raise GraphQL::RequiredImplementationMissingError
+        end
+
+        class << self
+          private
+
+          def build_visitor_hooks(member_name)
+            class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              def on_enter_#{member_name}(node, parent, visitor)
+              end
+
+              def on_leave_#{member_name}(node, parent, visitor)
+              end
+            EOS
+          end
+        end
+
+        build_visitor_hooks :argument
+        build_visitor_hooks :directive
+        build_visitor_hooks :document
+        build_visitor_hooks :enum
+        build_visitor_hooks :field
+        build_visitor_hooks :fragment_spread
+        build_visitor_hooks :inline_fragment
+        build_visitor_hooks :input_object
+        build_visitor_hooks :list_type
+        build_visitor_hooks :non_null_type
+        build_visitor_hooks :null_value
+        build_visitor_hooks :operation_definition
+        build_visitor_hooks :type_name
+        build_visitor_hooks :variable_definition
+        build_visitor_hooks :variable_identifier
+        build_visitor_hooks :abstract_node
+
+        protected
+
+        # @return [GraphQL::Query, GraphQL::Execution::Multiplex] Whatever this analyzer is analyzing
+        attr_reader :subject
+
+        # @return [GraphQL::Query, nil] `nil` if this analyzer is visiting a multiplex
+        #  (When this is `nil`, use `visitor.query` inside visit methods to get the current query)
+        attr_reader :query
+
+        # @return [GraphQL::Execution::Multiplex, nil] `nil` if this analyzer is visiting a query
+        attr_reader :multiplex
+      end
+    end
+  end
+end

data/lib/graphql/analysis/ast/field_usage.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      class FieldUsage < Analyzer
+        def initialize(query)
+          super
+          @used_fields = Set.new
+          @used_deprecated_fields = Set.new
+          @used_deprecated_arguments = Set.new
+        end
+
+        def on_leave_field(node, parent, visitor)
+          field_defn = visitor.field_definition
+          field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
+          @used_fields << field
+          @used_deprecated_fields << field if field_defn.deprecation_reason
+
+          extract_deprecated_arguments(visitor.query.arguments_for(node, visitor.field_definition).argument_values)
+        end
+
+        def result
+          {
+            used_fields: @used_fields.to_a,
+            used_deprecated_fields: @used_deprecated_fields.to_a,
+            used_deprecated_arguments: @used_deprecated_arguments.to_a,
+          }
+        end
+
+        private
+
+        def extract_deprecated_arguments(argument_values)
+          argument_values.each_pair do |_argument_name, argument|
+            if argument.definition.deprecation_reason
+              @used_deprecated_arguments << argument.definition.path
+            end
+
+            if argument.definition.type.kind.input_object?
+              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            elsif argument.definition.type.list? && !argument.value.nil?
+              argument
+                .value
+                .select { |value| value.respond_to?(:arguments) }
+                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/analysis/ast/max_query_complexity.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative "./query_complexity"
+module GraphQL
+  module Analysis
+    module AST
+      # Used under the hood to implement complexity validation,
+      # see {Schema#max_complexity} and {Query#max_complexity}
+      class MaxQueryComplexity < QueryComplexity
+        def result
+          return if subject.max_complexity.nil?
+
+          total_complexity = max_possible_complexity
+
+          if total_complexity > subject.max_complexity
+            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/analysis/ast/max_query_depth.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      class MaxQueryDepth < QueryDepth
+        def result
+          configured_max_depth = if query
+            query.max_depth
+          else
+            multiplex.schema.max_depth
+          end
+
+          if configured_max_depth && @max_depth > configured_max_depth
+            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{configured_max_depth}")
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end