graphql_cody 1.13.0

data/lib/graphql/introspection/type_type.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class TypeType < Introspection::BaseObject
+      graphql_name "__Type"
+      description "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in "\
+                  "GraphQL as represented by the `__TypeKind` enum.\n\n"\
+                  "Depending on the kind of a type, certain fields describe information about that type. "\
+                  "Scalar types provide no information beyond a name and description, while "\
+                  "Enum types provide their values. Object and Interface types provide the fields "\
+                  "they describe. Abstract types, Union and Interface, provide the Object types "\
+                  "possible at runtime. List and NonNull types compose other types."
+
+      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
+      field :name, String
+      field :description, String
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")] do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")]
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")]
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")] do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")]  do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
+
+      def name
+        object.graphql_name
+      end
+
+      def kind
+        @object.kind.name
+      end
+
+      def enum_values(include_deprecated:)
+        if !@object.kind.enum?
+          nil
+        else
+          enum_values = @context.warden.enum_values(@object)
+
+          if !include_deprecated
+            enum_values = enum_values.select {|f| !f.deprecation_reason }
+          end
+
+          enum_values
+        end
+      end
+
+      def interfaces
+        if @object.kind.object? || @object.kind.interface?
+          @context.warden.interfaces(@object).sort_by(&:graphql_name)
+        else
+          nil
+        end
+      end
+
+      def input_fields(include_deprecated:)
+        if @object.kind.input_object?
+          args = @context.warden.arguments(@object)
+          args = args.reject(&:deprecation_reason) unless include_deprecated
+          args
+        else
+          nil
+        end
+      end
+
+      def possible_types
+        if @object.kind.abstract?
+          @context.warden.possible_types(@object).sort_by(&:graphql_name)
+        else
+          nil
+        end
+      end
+
+      def fields(include_deprecated:)
+        if !@object.kind.fields?
+          nil
+        else
+          fields = @context.warden.fields(@object)
+          if !include_deprecated
+            fields = fields.select {|f| !f.deprecation_reason }
+          end
+          fields.sort_by(&:name)
+        end
+      end
+
+      def of_type
+        @object.kind.wraps? ? @object.of_type : nil
+      end
+    end
+  end
+end

data/lib/graphql/introspection.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    def self.query(include_deprecated_args: false)
+      # The introspection query to end all introspection queries, copied from
+      # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
+      <<-QUERY
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      ...FullType
+    }
+    directives {
+      name
+      description
+      locations
+      args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+        ...InputValue
+      }
+    }
+  }
+}
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+      ...InputValue
+    }
+    type {
+      ...TypeRef
+    }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+    ...InputValue
+  }
+  interfaces {
+    ...TypeRef
+  }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes {
+    ...TypeRef
+  }
+}
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+  #{include_deprecated_args ? 'isDeprecated' : ''}
+  #{include_deprecated_args ? 'deprecationReason' : ''}
+}
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+      QUERY
+    end
+  end
+end
+
+require "graphql/introspection/base_object"
+require "graphql/introspection/input_value_type"
+require "graphql/introspection/enum_value_type"
+require "graphql/introspection/type_kind_enum"
+require "graphql/introspection/type_type"
+require "graphql/introspection/field_type"
+require "graphql/introspection/directive_location_enum"
+require "graphql/introspection/directive_type"
+require "graphql/introspection/schema_type"
+require "graphql/introspection/introspection_query"
+require "graphql/introspection/dynamic_fields"
+require "graphql/introspection/entry_points"

data/lib/graphql/invalid_name_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  class InvalidNameError < GraphQL::ExecutionError
+    attr_reader :name, :valid_regex
+    def initialize(name, valid_regex)
+      @name = name
+      @valid_regex = valid_regex
+      super("Names must match #{@valid_regex.inspect} but '#{@name}' does not")
+    end
+  end
+end

data/lib/graphql/invalid_null_error.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module GraphQL
+  # Raised automatically when a field's resolve function returns `nil`
+  # for a non-null field.
+  class InvalidNullError < GraphQL::RuntimeTypeError
+    # @return [GraphQL::BaseType] The owner of {#field}
+    attr_reader :parent_type
+
+    # @return [GraphQL::Field] The field which failed to return a value
+    attr_reader :field
+
+    # @return [nil, GraphQL::ExecutionError] The invalid value for this field
+    attr_reader :value
+
+    def initialize(parent_type, field, value)
+      @parent_type = parent_type
+      @field = field
+      @value = value
+      super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
+    end
+
+    # @return [Hash] An entry for the response's "errors" key
+    def to_h
+      { "message" => message }
+    end
+
+    # @deprecated always false
+    def parent_error?
+      false
+    end
+
+    class << self
+      attr_accessor :parent_class
+
+      def subclass_for(parent_class)
+        subclass = Class.new(self)
+        subclass.parent_class = parent_class
+        subclass
+      end
+
+      def inspect
+        if (name.nil? || parent_class.name.nil?) && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
+          "#{mutation.inspect}::#{parent_class.graphql_name}::InvalidNullError"
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language/block_string.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    module BlockString
+      # Remove leading and trailing whitespace from a block string.
+      # See "Block Strings" in https://github.com/facebook/graphql/blob/master/spec/Section%202%20--%20Language.md
+      def self.trim_whitespace(str)
+        # Early return for the most common cases:
+        if str == ""
+          return ""
+        elsif !(has_newline = str.include?("\n")) && !(str.start_with?(" "))
+          return str
+        end
+
+        lines = has_newline ? str.split("\n") : [str]
+        common_indent = nil
+
+        # find the common whitespace
+        lines.each_with_index do |line, idx|
+          if idx == 0
+            next
+          end
+          line_length = line.size
+          line_indent = if line.match?(/\A  [^ ]/)
+            2
+          elsif line.match?(/\A    [^ ]/)
+            4
+          elsif line.match?(/\A[^ ]/)
+            0
+          else
+            line[/\A */].size
+          end
+          if line_indent < line_length && (common_indent.nil? || line_indent < common_indent)
+            common_indent = line_indent
+          end
+        end
+
+        # Remove the common whitespace
+        if common_indent && common_indent > 0
+          lines.each_with_index do |line, idx|
+            if idx == 0
+              next
+            else
+              line.slice!(0, common_indent)
+            end
+          end
+        end
+
+        # Remove leading & trailing blank lines
+        while lines.size > 0 && lines[0].empty?
+          lines.shift
+        end
+        while lines.size > 0 && lines[-1].empty?
+          lines.pop
+        end
+
+        # Rebuild the string
+        lines.size > 1 ? lines.join("\n") : (lines.first || "")
+      end
+
+      def self.print(str, indent: '')
+        lines = str.split("\n")
+
+        block_str = "#{indent}\"\"\"\n".dup
+
+        lines.each do |line|
+          if line == ''
+            block_str << "\n"
+          else
+            sublines = break_line(line, 120 - indent.length)
+            sublines.each do |subline|
+              block_str << "#{indent}#{subline}\n"
+            end
+          end
+        end
+
+        block_str << "#{indent}\"\"\"\n".dup
+      end
+
+      private
+
+      def self.break_line(line, length)
+        return [line] if line.length < length + 5
+
+        parts = line.split(Regexp.new("((?: |^).{15,#{length - 40}}(?= |$))"))
+        return [line] if parts.length < 4
+
+        sublines = [parts.slice!(0, 3).join]
+
+        parts.each_with_index do |part, i|
+          next if i % 2 == 1
+          sublines << "#{part[1..-1]}#{parts[i + 1]}"
+        end
+
+        sublines
+      end
+    end
+  end
+end

data/lib/graphql/language/cache.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'graphql/version'
+require 'digest/sha2'
+
+module GraphQL
+  module Language
+    class Cache
+      def initialize(path)
+        @path = path
+      end
+
+      DIGEST = Digest::SHA256.new << GraphQL::VERSION
+      def fetch(filename)
+        hash = DIGEST.dup << filename
+        begin
+          hash << File.mtime(filename).to_i.to_s
+        rescue SystemCallError
+          return yield
+        end
+        cache_path = @path.join(hash.to_s)
+
+        if cache_path.exist?
+          Marshal.load(cache_path.read)
+        else
+          payload = yield
+          tmp_path = "#{cache_path}.#{rand}"
+
+          @path.mkpath
+          File.binwrite(tmp_path, Marshal.dump(payload))
+          File.rename(tmp_path, cache_path.to_s)
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language/definition_slice.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    module DefinitionSlice
+      extend self
+
+      def slice(document, name)
+        definitions = {}
+        document.definitions.each { |d| definitions[d.name] = d }
+        names = Set.new
+        DependencyVisitor.find_definition_dependencies(definitions, name, names)
+        definitions = document.definitions.select { |d| names.include?(d.name) }
+        Nodes::Document.new(definitions: definitions)
+      end
+
+      private
+
+      class DependencyVisitor < GraphQL::Language::Visitor
+        def initialize(doc, definitions, names)
+          @names = names
+          @definitions = definitions
+          super(doc)
+        end
+
+        def on_fragment_spread(node, parent)
+          if fragment = @definitions[node.name]
+            self.class.find_definition_dependencies(@definitions, fragment.name, @names)
+          end
+          super
+        end
+
+        def self.find_definition_dependencies(definitions, name, names)
+          names.add(name)
+          visitor = self.new(definitions[name], definitions, names)
+          visitor.visit
+          nil
+        end
+      end
+    end
+  end
+end