graphql_cody 1.13.0

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasAstNode
+        # If this schema was parsed from a `.graphql` file (or other SDL),
+        # this is the AST node that defined this part of the schema.
+        def ast_node(new_ast_node = nil)
+          if new_ast_node
+            @ast_node = new_ast_node
+          elsif defined?(@ast_node)
+            @ast_node
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDeprecationReason
+        # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
+        def deprecation_reason
+          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
+          dir && dir.arguments[:reason] # rubocop:disable Development/ContextIsPassedCop -- definition-related
+        end
+
+        # Set the deprecation reason for this member, or remove it by assigning `nil`
+        # @param text [String, nil]
+        def deprecation_reason=(text)
+          if text.nil?
+            remove_directive(GraphQL::Schema::Directive::Deprecated)
+          else
+            directive(GraphQL::Schema::Directive::Deprecated, reason: text)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDirectives
+        # Create an instance of `dir_class` for `self`, using `options`.
+        #
+        # It removes a previously-attached instance of `dir_class`, if there is one.
+        #
+        # @return [void]
+        def directive(dir_class, **options)
+          @own_directives ||= []
+          remove_directive(dir_class)
+          @own_directives << dir_class.new(self, **options)
+          nil
+        end
+
+        # Remove an attached instance of `dir_class`, if there is one
+        # @param dir_class [Class<GraphQL::Schema::Directive>]
+        # @return [viod]
+        def remove_directive(dir_class)
+          @own_directives && @own_directives.reject! { |d| d.is_a?(dir_class) }
+          nil
+        end
+
+        NO_DIRECTIVES = [].freeze
+
+        def directives
+          case self
+          when Class
+            inherited_directives = if superclass.respond_to?(:directives)
+              superclass.directives
+            else
+              NO_DIRECTIVES
+            end
+            if inherited_directives.any? && @own_directives
+              dirs = []
+              merge_directives(dirs, inherited_directives)
+              merge_directives(dirs, @own_directives)
+              dirs
+            elsif @own_directives
+              @own_directives
+            elsif inherited_directives.any?
+              inherited_directives
+            else
+              NO_DIRECTIVES
+            end
+          when Module
+            dirs = nil
+            self.ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_directives) &&
+                  (anc_dirs = ancestor.own_directives).any?
+                dirs ||= []
+                merge_directives(dirs, anc_dirs)
+              end
+            end
+            if own_directives
+              dirs ||= []
+              merge_directives(dirs, own_directives)
+            end
+            dirs || NO_DIRECTIVES
+          when HasDirectives
+            @own_directives || NO_DIRECTIVES
+          else
+            raise "Invariant: how could #{self} not be a Class, Module, or instance of HasDirectives?"
+          end
+        end
+
+        protected
+
+        def own_directives
+          @own_directives
+        end
+
+        private
+
+        # Modify `target` by adding items from `dirs` such that:
+        # - Any name conflict is overriden by the incoming member of `dirs`
+        # - Any other member of `dirs` is appended
+        # @param target [Array<GraphQL::Schema::Directive>]
+        # @param dirs [Array<GraphQL::Schema::Directive>]
+        # @return [void]
+        def merge_directives(target, dirs)
+          dirs.each do |dir|
+            if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
+              target.slice!(idx)
+              target.insert(idx, dir)
+            else
+              target << dir
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Shared code for Objects, Interfaces, Mutations, Subscriptions
+      module HasFields
+        # Add a field to this object or interface with the given definition
+        # @see {GraphQL::Schema::Field#initialize} for method signature
+        # @return [GraphQL::Schema::Field]
+        def field(*args, **kwargs, &block)
+          field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
+          add_field(field_defn)
+          field_defn
+        end
+
+        # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+        def fields(context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          is_object = self.respond_to?(:kind) && self.kind.object?
+          # Local overrides take precedence over inherited fields
+          visible_fields = {}
+          for ancestor in ancestors
+            if ancestor.respond_to?(:own_fields) &&
+                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true)
+
+              ancestor.own_fields.each do |field_name, fields_entry|
+                # Choose the most local definition that passes `.visible?` --
+                # stop checking for fields by name once one has been found.
+                if !visible_fields.key?(field_name) && (f = Warden.visible_entry?(:visible_field?, fields_entry, context, warden))
+                  visible_fields[field_name] = f
+                end
+              end
+            end
+          end
+          visible_fields
+        end
+
+        def get_field(field_name, context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          is_object = self.respond_to?(:kind) && self.kind.object?
+          for ancestor in ancestors
+            if ancestor.respond_to?(:own_fields) &&
+                (is_object ? visible_interface_implementation?(ancestor, context, warden) : true) &&
+                (f_entry = ancestor.own_fields[field_name]) &&
+                (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
+              return f
+            end
+          end
+          nil
+        end
+
+        # A list of Ruby keywords.
+        #
+        # @api private
+        RUBY_KEYWORDS = [:class, :module, :def, :undef, :begin, :rescue, :ensure, :end, :if, :unless, :then, :elsif, :else, :case, :when, :while, :until, :for, :break, :next, :redo, :retry, :in, :do, :return, :yield, :super, :self, :nil, :true, :false, :and, :or, :not, :alias, :defined?, :BEGIN, :END, :__LINE__, :__FILE__]
+
+        # A list of GraphQL-Ruby keywords.
+        #
+        # @api private
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :raw_value]
+
+        # A list of field names that we should advise users to pick a different
+        # resolve method name.
+        #
+        # @api private
+        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS + Object.instance_methods)
+
+        # Register this field with the class, overriding a previous one if needed.
+        # @param field_defn [GraphQL::Schema::Field]
+        # @return [void]
+        def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
+          # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
+          # that shows that no override value was given manually.
+          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym
+            warn(conflict_field_name_warning(field_defn))
+          end
+          prev_defn = own_fields[field_defn.name]
+
+          case prev_defn
+          when nil
+            own_fields[field_defn.name] = field_defn
+          when Array
+            prev_defn << field_defn
+          when GraphQL::Schema::Field
+            own_fields[field_defn.name] = [prev_defn, field_defn]
+          else
+            raise "Invariant: unexpected previous field definition for #{field_defn.name.inspect}: #{prev_defn.inspect}"
+          end
+
+          nil
+        end
+
+        # @return [Class] The class to initialize when adding fields to this kind of schema member
+        def field_class(new_field_class = nil)
+          if new_field_class
+            @field_class = new_field_class
+          elsif defined?(@field_class) && @field_class
+            @field_class
+          else
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
+          end
+        end
+
+        def global_id_field(field_name, **kwargs)
+          id_resolver = GraphQL::Relay::GlobalIdResolve.new(type: self)
+          field field_name, "ID", **kwargs, null: false
+          define_method(field_name) do
+            id_resolver.call(object, {}, context)
+          end
+        end
+
+        # @return [Hash<String => GraphQL::Schema::Field, Array<GraphQL::Schema::Field>>] Fields defined on this class _specifically_, not parent classes
+        def own_fields
+          @own_fields ||= {}
+        end
+
+        def all_field_definitions
+          all_fields = {}
+          ancestors.reverse_each do |ancestor|
+            if ancestor.respond_to?(:own_fields)
+              all_fields.merge!(ancestor.own_fields)
+            end
+          end
+          all_fields = all_fields.values
+          all_fields.flatten!
+          all_fields
+        end
+
+        private
+
+        # If `type` is an interface, and `self` has a type membership for `type`, then make sure it's visible.
+        def visible_interface_implementation?(type, context, warden)
+          if type.respond_to?(:kind) && type.kind.interface?
+            implements_this_interface = false
+            implementation_is_visible = false
+            interface_type_memberships.each do |tm|
+              if tm.abstract_type == type
+                implements_this_interface ||= true
+                if warden.visible_type_membership?(tm, context)
+                  implementation_is_visible = true
+                  break
+                end
+              end
+            end
+            # It's possible this interface came by way of `include` in another interface which this
+            # object type _does_ implement, and that's ok
+            implements_this_interface ? implementation_is_visible : true
+          else
+            # If there's no implementation, then we're looking at Ruby-style inheritance instead
+            true
+          end
+        end
+
+        # @param [GraphQL::Schema::Field]
+        # @return [String] A warning to give when this field definition might conflict with a built-in method
+        def conflict_field_name_warning(field_defn)
+          "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`). Or use `method_conflict_warning: false` to suppress this warning."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasInterfaces
+        def implements(*new_interfaces, **options)
+          new_memberships = []
+          new_interfaces.each do |int|
+            if int.is_a?(Module)
+              unless int.include?(GraphQL::Schema::Interface)
+                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+              end
+
+              new_memberships << int.type_membership_class.new(int, self, **options)
+
+              # Include the methods here,
+              # `.fields` will use the inheritance chain
+              # to find inherited fields
+              include(int)
+
+              # If this interface has interfaces of its own, add those, too
+              int.interfaces.each do |next_interface|
+                implements(next_interface)
+              end
+            elsif int.is_a?(GraphQL::InterfaceType)
+              new_memberships << int.type_membership_class.new(int, self, **options)
+            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
+              if options.any?
+                raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
+              end
+              new_memberships << int
+            else
+              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
+            end
+          end
+
+          # Remove any String or late-bound interfaces which are being replaced
+          own_interface_type_memberships.reject! { |old_i_m|
+            if !(old_i_m.respond_to?(:abstract_type) && old_i_m.abstract_type.is_a?(Module))
+              old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
+              old_name = Schema::Member::BuildType.to_type_name(old_int_type)
+
+              new_memberships.any? { |new_i_m|
+                new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
+                new_name = Schema::Member::BuildType.to_type_name(new_int_type)
+
+                new_name == old_name
+              }
+            end
+          }
+          own_interface_type_memberships.concat(new_memberships)
+        end
+
+        def own_interface_type_memberships
+          @own_interface_type_memberships ||= []
+        end
+
+        def interface_type_memberships
+          own_interface_type_memberships + ((self.is_a?(Class) && superclass.respond_to?(:interface_type_memberships)) ? superclass.interface_type_memberships : [])
+        end
+
+        # param context [Query::Context] If omitted, skip filtering.
+        def interfaces(context = GraphQL::Query::NullContext)
+          warden = Warden.from_context(context)
+          visible_interfaces = []
+          own_interface_type_memberships.each do |type_membership|
+            # During initialization, `type_memberships` can hold late-bound types
+            case type_membership
+            when String, Schema::LateBoundType
+              visible_interfaces << type_membership
+            when Schema::TypeMembership
+              if warden.visible_type_membership?(type_membership, context)
+                visible_interfaces << type_membership.abstract_type
+              end
+            else
+              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
+            end
+          end
+
+          if self.is_a?(Class) && superclass <= GraphQL::Schema::Object
+            visible_interfaces.concat(superclass.interfaces(context))
+          end
+
+          visible_interfaces
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasPath
+        # @return [String] A description of this member's place in the GraphQL schema
+        def path
+          path_str = if self.respond_to?(:graphql_name)
+            self.graphql_name
+          elsif self.class.respond_to?(:graphql_name)
+            # Instances of resolvers
+            self.class.graphql_name
+          end
+
+          if self.respond_to?(:owner) && owner.respond_to?(:path)
+            path_str = "#{owner.path}.#{path_str}"
+          end
+
+          path_str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Set up a type-specific error to make debugging & bug tracker integration better
+      module HasUnresolvedTypeError
+        private
+        def add_unresolved_type_error(child_class)
+          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasValidators
+        include Schema::FindInheritedValue::EmptyObjects
+
+        # Build {GraphQL::Schema::Validator}s based on the given configuration
+        # and use them for this schema member
+        # @param validation_config [Hash{Symbol => Hash}]
+        # @return [void]
+        def validates(validation_config)
+          new_validators = GraphQL::Schema::Validator.from_config(self, validation_config)
+          @own_validators ||= []
+          @own_validators.concat(new_validators)
+          nil
+        end
+
+        # @return [Array<GraphQL::Schema::Validator>]
+        def validators
+          own_validators = @own_validators || EMPTY_ARRAY
+          if self.is_a?(Class) && superclass.respond_to?(:validators) && (inherited_validators = superclass.validators).any?
+            inherited_validators + own_validators
+          else
+            own_validators
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module Instrumentation
+        module_function
+        def instrument(type, field)
+          return_type = field.type.unwrap
+          if (return_type.is_a?(GraphQL::ObjectType) && return_type.metadata[:type_class]) ||
+              return_type.is_a?(GraphQL::InterfaceType) ||
+              (return_type.is_a?(GraphQL::UnionType) && return_type.possible_types.any? { |t| t.metadata[:type_class] })
+            field = apply_proxy(field)
+          end
+
+          field
+        end
+
+        def before_query(query)
+          # Get the root type for this query
+          root_node = query.irep_selection
+          if root_node.nil?
+            # It's an invalid query, nothing to do here
+          else
+            root_type = query.irep_selection.return_type
+            # If it has a wrapper, apply it
+            wrapper_class = root_type.metadata[:type_class]
+            if wrapper_class
+              new_root_value = wrapper_class.authorized_new(query.root_value, query.context)
+              new_root_value = query.schema.sync_lazy(new_root_value)
+              if new_root_value.nil?
+                # This is definitely a hack,
+                # but we need some way to tell execute.rb not to run.
+                query.context[:__root_unauthorized] = true
+              end
+              query.root_value = new_root_value
+            end
+          end
+        end
+
+        def after_query(_query)
+        end
+
+        private
+
+        module_function
+
+        def apply_proxy(field)
+          resolve_proc = field.resolve_proc
+          lazy_resolve_proc = field.lazy_resolve_proc
+          inner_return_type = field.type.unwrap
+          depth = list_depth(field.type)
+
+          field.redefine(
+            resolve: ProxiedResolve.new(inner_resolve: resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
+            lazy_resolve: ProxiedResolve.new(inner_resolve: lazy_resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
+          )
+        end
+
+        def list_depth(type, starting_at = 0)
+          case type
+          when GraphQL::ListType
+            list_depth(type.of_type, starting_at + 1)
+          when GraphQL::NonNullType
+            list_depth(type.of_type, starting_at)
+          else
+            starting_at
+          end
+        end
+
+        class ProxiedResolve
+          def initialize(inner_resolve:, list_depth:, inner_return_type:)
+            @inner_resolve = inner_resolve
+            @inner_return_type = inner_return_type
+            @list_depth = list_depth
+          end
+
+          def call(obj, args, ctx)
+            result = @inner_resolve.call(obj, args, ctx)
+            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || execution_errors?(result) || ctx.wrapped_object
+              result
+            else
+              ctx.wrapped_object = true
+              proxy_to_depth(result, @list_depth, ctx)
+            end
+          end
+
+          private
+
+          def execution_errors?(result)
+            result.is_a?(GraphQL::ExecutionError) ||
+              (result.is_a?(Array) && result.any? && result.all? { |v| v.is_a?(GraphQL::ExecutionError) })
+          end
+
+          def proxy_to_depth(inner_obj, depth, ctx)
+            if depth > 0
+              inner_obj.map { |i| proxy_to_depth(i, depth - 1, ctx) }
+            else
+              ctx.schema.after_lazy(inner_obj) do |inner_obj|
+                if inner_obj.nil?
+                  # For lists with nil, we need another nil check here
+                  nil
+                else
+                  concrete_type_or_lazy = case @inner_return_type
+                  when GraphQL::UnionType, GraphQL::InterfaceType
+                    ctx.query.resolve_type(@inner_return_type, inner_obj)
+                  when GraphQL::ObjectType
+                    @inner_return_type
+                  else
+                    raise "unexpected proxying type #{@inner_return_type} for #{inner_obj} at #{ctx.owner_type}.#{ctx.field.name}"
+                  end
+
+                  # .resolve_type may have returned a lazy
+                  ctx.schema.after_lazy(concrete_type_or_lazy) do |concrete_type|
+                    if concrete_type && (object_class = concrete_type.metadata[:type_class])
+                      # use the query-level context here, since it won't be field-specific anyways
+                      query_ctx = ctx.query.context
+                      object_class.authorized_new(inner_obj, query_ctx)
+                    else
+                      inner_obj
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module RelayShortcuts
+        def edge_type_class(new_edge_type_class = nil)
+          if new_edge_type_class
+            @edge_type_class = new_edge_type_class
+          else
+            @edge_type_class || find_inherited_value(:edge_type_class, Types::Relay::BaseEdge)
+          end
+        end
+
+        def connection_type_class(new_connection_type_class = nil)
+          if new_connection_type_class
+            @connection_type_class = new_connection_type_class
+          else
+            @connection_type_class || find_inherited_value(:connection_type_class, Types::Relay::BaseConnection)
+          end
+        end
+
+        def edge_type
+          @edge_type ||= begin
+            edge_name = self.graphql_name + "Edge"
+            node_type_class = self
+            Class.new(edge_type_class) do
+              graphql_name(edge_name)
+              node_type(node_type_class)
+            end
+          end
+        end
+
+        def connection_type
+          @connection_type ||= begin
+            conn_name = self.graphql_name + "Connection"
+            edge_type_class = self.edge_type
+            Class.new(connection_type_class) do
+              graphql_name(conn_name)
+              edge_type(edge_type_class)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module Scoped
+        # This is called when a field has `scope: true`.
+        # The field's return type class receives this call.
+        #
+        # By default, it's a no-op. Override it to scope your objects.
+        #
+        # @param items [Object] Some list-like object (eg, Array, ActiveRecord::Relation)
+        # @param context [GraphQL::Query::Context]
+        # @return [Object] Another list-like object, scoped to the current context
+        def scope_items(items, context)
+          items
+        end
+      end
+    end
+  end
+end