graphql_cody 1.13.0

data/lib/graphql/schema/introspection_system.rb

@@ -0,0 +1,169 @@
+# 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, GraphQL::ListType
+          resolve_late_binding(late_bound_type.of_type).to_list_type
+        when GraphQL::Schema::NonNull, GraphQL::NonNullType
+          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)
+        if @class_based
+          dup_type_class(const)
+        else
+          # Use `.to_graphql` to get a freshly-made version, not shared between schemas
+          const.to_graphql
+        end
+      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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class InvalidTypeError < GraphQL::Error
+    end
+  end
+end

data/lib/graphql/schema/late_bound_type.rb

@@ -0,0 +1,33 @@
+# 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::NonNullType.new(of_type: self)
+      end
+
+      def to_list_type
+        @to_list_type ||= GraphQL::ListType.new(of_type: self)
+      end
+
+      def inspect
+        "#<LateBoundType @name=#{name}>"
+      end
+
+      alias :to_s :inspect
+    end
+  end
+end

data/lib/graphql/schema/list.rb

@@ -0,0 +1,75 @@
+# 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
+
+      def to_graphql
+        @of_type.graphql_definition.to_list_type
+      end
+
+      # @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)
+        result = GraphQL::Query::InputValidationResult.new
+        ensure_array(value).each_with_index do |item, index|
+          item_result = of_type.validate_input(item, ctx)
+          if !item_result.valid?
+            result.merge_result!(index, item_result)
+          end
+        end
+        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
+    end
+  end
+end

data/lib/graphql/schema/loader.rb

@@ -0,0 +1,226 @@
+# 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)
+
+          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"])
+              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))
+            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,
+              method_access: 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

data/lib/graphql/schema/member/accepts_definition.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Support for legacy `accepts_definitions` functions.
+      #
+      # Keep the legacy handler hooked up. Class-based types and fields
+      # will call those legacy handlers during their `.to_graphql`
+      # methods.
+      #
+      # This can help out while transitioning from one to the other.
+      # Eventually, `GraphQL::{X}Type` objects will be removed entirely,
+      # But this can help during the transition.
+      #
+      # @example Applying a function to base object class
+      #   # Here's the legacy-style config, which we're calling back to:
+      #   GraphQL::ObjectType.accepts_definition({
+      #     permission_level: ->(defn, value) { defn.metadata[:permission_level] = value }
+      #   })
+      #
+      #   class BaseObject < GraphQL::Schema::Object
+      #     # Setup a named pass-through to the legacy config functions
+      #     accepts_definition :permission_level
+      #   end
+      #
+      #   class Account < BaseObject
+      #     # This value will be passed to the legacy handler:
+      #     permission_level 1
+      #   end
+      #
+      #   # The class gets a reader method which returns the args,
+      #   # only marginally useful.
+      #   Account.permission_level # => [1]
+      #
+      #   # The legacy handler is called, as before:
+      #   Account.graphql_definition.metadata[:permission_level] # => 1
+      module AcceptsDefinition
+        def self.included(child)
+          child.extend(AcceptsDefinitionDefinitionMethods)
+          child.prepend(ToGraphQLExtension)
+          child.prepend(InitializeExtension)
+        end
+
+        def self.extended(child)
+          if defined?(child::DefinitionMethods)
+            child::DefinitionMethods.include(AcceptsDefinitionDefinitionMethods)
+            child::DefinitionMethods.prepend(ToGraphQLExtension)
+          else
+            child.extend(AcceptsDefinitionDefinitionMethods)
+            # I tried to use `super`, but super isn't quite right
+            # since the method is defined in the same class itself,
+            # not the superclass
+            child.class_eval do
+              class << self
+                prepend(ToGraphQLExtension)
+              end
+            end
+          end
+        end
+
+        module AcceptsDefinitionDefinitionMethods
+          def accepts_definition(name)
+            own_accepts_definition_methods << name
+
+            ivar_name = "@#{name}_args"
+            if self.is_a?(Class)
+              define_singleton_method(name) do |*args|
+                if args.any?
+                  instance_variable_set(ivar_name, args)
+                end
+                instance_variable_get(ivar_name) || (superclass.respond_to?(name) ? superclass.public_send(name) : nil)
+              end
+
+              define_method(name) do |*args|
+                if args.any?
+                  instance_variable_set(ivar_name, args)
+                end
+                instance_variable_get(ivar_name)
+              end
+            else
+              # Special handling for interfaces, define it here
+              # so it's appropriately passed down
+              self::DefinitionMethods.module_eval do
+                define_method(name) do |*args|
+                  if args.any?
+                    instance_variable_set(ivar_name, args)
+                  else
+                    if (v = instance_variable_get(ivar_name))
+                      v
+                    elsif (ancestor = ancestors.find { |i| i.respond_to?(name) && i != self })
+                      ancestor.public_send(name)
+                    else
+                      nil
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def accepts_definition_methods
+            inherited_methods = if self.is_a?(Class)
+              superclass.respond_to?(:accepts_definition_methods) ? superclass.accepts_definition_methods : []
+            elsif self.is_a?(Module)
+              m = []
+              ancestors.each do |a|
+                if a.respond_to?(:own_accepts_definition_methods)
+                  m.concat(a.own_accepts_definition_methods)
+                end
+              end
+              m
+            else
+              self.class.accepts_definition_methods
+            end
+
+            own_accepts_definition_methods + inherited_methods
+          end
+
+          def own_accepts_definition_methods
+            @own_accepts_definition_methods ||= []
+          end
+        end
+
+        module ToGraphQLExtension
+          def to_graphql
+            defn = super
+            accepts_definition_methods.each do |method_name|
+              value = public_send(method_name)
+              if !value.nil?
+                defn = defn.redefine { public_send(method_name, *value) }
+              end
+            end
+            defn
+          end
+        end
+
+        module InitializeExtension
+          def initialize(*args, **kwargs, &block)
+            self.class.accepts_definition_methods.each do |method_name|
+              if kwargs.key?(method_name)
+                value = kwargs.delete(method_name)
+                if !value.is_a?(Array)
+                  value = [value]
+                end
+                instance_variable_set("@#{method_name}_args", value)
+              end
+            end
+            super(*args, **kwargs, &block)
+          end
+
+          def accepts_definition_methods
+            self.class.accepts_definition_methods
+          end
+        end
+      end
+    end
+  end
+end