graphql_cody 1.13.0

data/lib/graphql/schema/timeout.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This plugin will stop resolving new fields after `max_seconds` have elapsed.
+    # After the time has passed, any remaining fields will be `nil`, with errors added
+    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
+    # you'll get a partial response.
+    #
+    # You can subclass `GraphQL::Schema::Timeout` and override `max_seconds` and/or `handle_timeout`
+    # to provide custom logic when a timeout error occurs.
+    #
+    # Note that this will stop a query _in between_ field resolutions, but
+    # it doesn't interrupt long-running `resolve` functions. Be sure to use
+    # timeout options for external connections. For more info, see
+    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
+    #
+    # @example Stop resolving fields after 2 seconds
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Schema::Timeout, max_seconds: 2
+    #   end
+    #
+    # @example Notifying Bugsnag and logging a timeout
+    #   class MyTimeout < GraphQL::Schema::Timeout
+    #     def handle_timeout(error, query)
+    #        Rails.logger.warn("GraphQL Timeout: #{error.message}: #{query.query_string}")
+    #        Bugsnag.notify(error, {query_string: query.query_string})
+    #     end
+    #   end
+    #
+    #   class MySchema < GraphQL::Schema
+    #     use MyTimeout, max_seconds: 2
+    #   end
+    #
+    class Timeout
+      def self.use(schema, **options)
+        tracer = new(**options)
+        schema.tracer(tracer)
+      end
+
+      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+      def initialize(max_seconds:)
+        @max_seconds = max_seconds
+      end
+
+      def trace(key, data)
+        case key
+        when 'execute_multiplex'
+          data.fetch(:multiplex).queries.each do |query|
+            timeout_duration_s = max_seconds(query)
+            timeout_state = if timeout_duration_s == false
+              # if the method returns `false`, don't apply a timeout
+              false
+            else
+              now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+              timeout_at = now + (max_seconds(query) * 1000)
+              {
+                timeout_at: timeout_at,
+                timed_out: false
+              }
+            end
+            query.context.namespace(self.class)[:state] = timeout_state
+          end
+
+          yield
+        when 'execute_field', 'execute_field_lazy'
+          query_context = data[:context] || data[:query].context
+          timeout_state = query_context.namespace(self.class).fetch(:state)
+          # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
+          if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
+            error = if data[:context]
+              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
+            else
+              field = data.fetch(:field)
+              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
+            end
+
+            # Only invoke the timeout callback for the first timeout
+            if !timeout_state[:timed_out]
+              timeout_state[:timed_out] = true
+              handle_timeout(error, query_context.query)
+            end
+
+            error
+          else
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      # Called at the start of each query.
+      # The default implementation returns the `max_seconds:` value from installing this plugin.
+      #
+      # @param query [GraphQL::Query] The query that's about to run
+      # @return [Integer, false] The number of seconds after which to interrupt query execution and call {#handle_error}, or `false` to bypass the timeout.
+      def max_seconds(query)
+        @max_seconds
+      end
+
+      # Invoked when a query times out.
+      # @param error [GraphQL::Schema::Timeout::TimeoutError]
+      # @param query [GraphQL::Error]
+      def handle_timeout(error, query)
+        # override to do something interesting
+      end
+
+      # This error is raised when a query exceeds `max_seconds`.
+      # Since it's a child of {GraphQL::ExecutionError},
+      # its message will be added to the response's `errors` key.
+      #
+      # To raise an error that will stop query resolution, use a custom block
+      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
+      # such as `RuntimeError`.
+      class TimeoutError < GraphQL::ExecutionError
+        def initialize(parent_type, field)
+          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/timeout_middleware.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require "delegate"
+
+module GraphQL
+  class Schema
+    # This middleware will stop resolving new fields after `max_seconds` have elapsed.
+    # After the time has passed, any remaining fields will be `nil`, with errors added
+    # to the `errors` key. Any already-resolved fields will be in the `data` key, so
+    # you'll get a partial response.
+    #
+    # You can provide a block which will be called with any timeout errors that occur.
+    #
+    # Note that this will stop a query _in between_ field resolutions, but
+    # it doesn't interrupt long-running `resolve` functions. Be sure to use
+    # timeout options for external connections. For more info, see
+    # www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
+    #
+    # @example Stop resolving fields after 2 seconds
+    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware.new(max_seconds: 2)
+    #
+    # @example Notifying Bugsnag on a timeout
+    #   MySchema.middleware << GraphQL::Schema::TimeoutMiddleware(max_seconds: 1.5) do |timeout_error, query|
+    #    Bugsnag.notify(timeout_error, {query_string: query_ctx.query.query_string})
+    #   end
+    #
+    # @api deprecated
+    # @see Schema::Timeout
+    class TimeoutMiddleware
+      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+      def initialize(max_seconds:, context_key: nil, &block)
+        @max_seconds = max_seconds
+        if context_key
+          GraphQL::Deprecation.warn("TimeoutMiddleware's `context_key` is ignored, timeout data is now stored in isolated storage")
+        end
+        @error_handler = block
+      end
+
+      def call(parent_type, parent_object, field_definition, field_args, query_context)
+        ns = query_context.namespace(self.class)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        timeout_at = ns[:timeout_at] ||= now + @max_seconds
+
+        if timeout_at < now
+          on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
+        else
+          yield
+        end
+      end
+
+      # This is called when a field _would_ be resolved, except that we're over the time limit.
+      # @return [GraphQL::Schema::TimeoutMiddleware::TimeoutError] An error whose message will be added to the `errors` key
+      def on_timeout(parent_type, parent_object, field_definition, field_args, field_context)
+        err = GraphQL::Schema::TimeoutMiddleware::TimeoutError.new(parent_type, field_definition)
+        if @error_handler
+          query_proxy = TimeoutQueryProxy.new(field_context.query, field_context)
+          @error_handler.call(err, query_proxy)
+        end
+        err
+      end
+
+      # This behaves like {GraphQL::Query} but {#context} returns
+      # the _field-level_ context, not the query-level context.
+      # This means you can reliably get the `irep_node` and `path`
+      # from it after the fact.
+      class TimeoutQueryProxy < SimpleDelegator
+        def initialize(query, ctx)
+          @context = ctx
+          super(query)
+        end
+
+        attr_reader :context
+      end
+
+      # This error is raised when a query exceeds `max_seconds`.
+      # Since it's a child of {GraphQL::ExecutionError},
+      # its message will be added to the response's `errors` key.
+      #
+      # To raise an error that will stop query resolution, use a custom block
+      # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
+      # such as `RuntimeError`.
+      class TimeoutError < GraphQL::ExecutionError
+        def initialize(parent_type, field_defn)
+          super("Timeout on #{parent_type.name}.#{field_defn.name}")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/traversal.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Visit the members of this schema and build up artifacts for runtime.
+    # @api private
+    class Traversal
+      # @return [Hash<String => GraphQL::BaseType]
+      attr_reader :type_map
+
+      # @return [Hash<String => Hash<String => GraphQL::Field>>]
+      attr_reader :instrumented_field_map
+
+      # @return [Hash<String => Array<GraphQL::Field || GraphQL::Argument || GraphQL::Directive>]
+      attr_reader :type_reference_map
+
+      # @return [Hash<String => Array<GraphQL::BaseType>]
+      attr_reader :union_memberships
+
+
+      # @param schema [GraphQL::Schema]
+      def initialize(schema, introspection: true)
+        @schema = schema
+        @introspection = introspection
+        built_in_insts = [
+          GraphQL::Relay::ConnectionInstrumentation,
+          GraphQL::Relay::EdgesInstrumentation,
+          GraphQL::Relay::Mutation::Instrumentation,
+        ]
+
+        if schema.query_execution_strategy != GraphQL::Execution::Interpreter
+          built_in_insts << GraphQL::Schema::Member::Instrumentation
+        end
+
+        @field_instrumenters =
+          schema.instrumenters[:field] +
+            built_in_insts +
+            schema.instrumenters[:field_after_built_ins]
+
+        # These fields have types specified by _name_,
+        # So we need to inspect the schema and find those types,
+        # then update their references.
+        @late_bound_fields = []
+        @type_map = {}
+        @instrumented_field_map = Hash.new { |h, k| h[k] = {} }
+        @type_reference_map = Hash.new { |h, k| h[k] = [] }
+        @union_memberships = Hash.new { |h, k| h[k] = [] }
+        visit(schema, schema, nil)
+        resolve_late_bound_fields
+      end
+
+      private
+
+      # A brute-force appraoch to late binding.
+      # Just keep trying the whole list, hoping that they
+      # eventually all resolve.
+      # This could be replaced with proper dependency tracking.
+      def resolve_late_bound_fields
+        # This is a bit tricky, with the writes going to internal state.
+        prev_late_bound_fields = @late_bound_fields
+        # Things might get added here during `visit...`
+        # or they might be added manually if we can't find them by hand
+        @late_bound_fields = []
+        prev_late_bound_fields.each do |(owner_type, field_defn, dynamic_field)|
+          if @type_map.key?(field_defn.type.unwrap.name)
+            late_bound_return_type = field_defn.type
+            resolved_type = @type_map.fetch(late_bound_return_type.unwrap.name)
+            wrapped_resolved_type = rewrap_resolved_type(late_bound_return_type, resolved_type)
+            # Update the field definition in place? :thinking_face:
+            field_defn.type = wrapped_resolved_type
+            visit_field_on_type(@schema, owner_type, field_defn, dynamic_field: dynamic_field)
+          else
+            @late_bound_fields << [owner_type, field_defn, dynamic_field]
+          end
+        end
+
+        if @late_bound_fields.any?
+          # If we visited each field and failed to resolve _any_,
+          # then we're stuck.
+          if @late_bound_fields == prev_late_bound_fields
+            type_names = prev_late_bound_fields.map { |f| f[1] }.map(&:type).map(&:unwrap).map(&:name).uniq
+            raise <<-ERR
+Some late-bound types couldn't be resolved:
+
+- #{type_names}
+- Found __* types: #{@type_map.keys.select { |k| k.start_with?("__") }}
+            ERR
+          else
+            resolve_late_bound_fields
+          end
+        end
+      end
+
+      # The late-bound type may be wrapped with list or non-null types.
+      # Apply the same wrapping to the resolve type and
+      # return the maybe-wrapped type
+      def rewrap_resolved_type(late_bound_type, resolved_inner_type)
+        case late_bound_type
+        when GraphQL::NonNullType
+          rewrap_resolved_type(late_bound_type.of_type, resolved_inner_type).to_non_null_type
+        when GraphQL::ListType
+          rewrap_resolved_type(late_bound_type.of_type, resolved_inner_type).to_list_type
+        when GraphQL::Schema::LateBoundType
+          resolved_inner_type
+        else
+          raise "Unexpected late_bound_type: #{late_bound_type.inspect} (#{late_bound_type.class})"
+        end
+      end
+
+      def visit(schema, member, context_description)
+        case member
+        when GraphQL::Schema
+          member.directives.each { |name, directive| visit(schema, directive, "Directive #{name}") }
+          # Find the starting points, then visit them
+          visit_roots = [member.query, member.mutation, member.subscription]
+          if @introspection
+            introspection_types = schema.introspection_system.types.values
+            visit_roots.concat(introspection_types)
+            if member.query
+              member.introspection_system.entry_points.each do |introspection_field|
+                # Visit this so that arguments class is preconstructed
+                # Skip validation since it begins with "__"
+                visit_field_on_type(schema, member.query, introspection_field, dynamic_field: true)
+              end
+            end
+          end
+          visit_roots.concat(member.orphan_types)
+          visit_roots.compact!
+          visit_roots.each { |t| visit(schema, t, t.name) }
+        when GraphQL::Directive
+          member.arguments.each do |name, argument|
+            @type_reference_map[argument.type.unwrap.to_s] << argument
+            visit(schema, argument.type, "Directive argument #{member.name}.#{name}")
+          end
+          # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
+          # to be passed to a resolver proc
+          GraphQL::Query::Arguments.construct_arguments_class(member)
+        when GraphQL::BaseType
+          type_defn = member.unwrap
+          prev_type = @type_map[type_defn.name]
+          # Continue to visit this type if it's the first time we've seen it:
+          if prev_type.nil?
+            validate_type(type_defn, context_description)
+            @type_map[type_defn.name] = type_defn
+            case type_defn
+            when GraphQL::ObjectType
+              type_defn.interfaces.each { |i| visit(schema, i, "Interface on #{type_defn.name}") }
+              visit_fields(schema, type_defn)
+            when GraphQL::InterfaceType
+              visit_fields(schema, type_defn)
+              type_defn.orphan_types.each do |t|
+                visit(schema, t, "Orphan type for #{type_defn.name}")
+              end
+            when GraphQL::UnionType
+              type_defn.possible_types.each do |t|
+                @union_memberships[t.name] << type_defn
+                visit(schema, t, "Possible type for #{type_defn.name}")
+              end
+            when GraphQL::InputObjectType
+              type_defn.arguments.each do |name, arg|
+                @type_reference_map[arg.type.unwrap.to_s] << arg
+                visit(schema, arg.type, "Input field #{type_defn.name}.#{name}")
+              end
+
+              # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
+              # to be passed to a resolver proc
+              if type_defn.arguments_class.nil?
+                GraphQL::Query::Arguments.construct_arguments_class(type_defn)
+              end
+            end
+          elsif !prev_type.equal?(type_defn)
+            # If the previous entry in the map isn't the same object we just found, raise.
+            raise("Duplicate type definition found for name '#{type_defn.name}' at '#{context_description}' (#{prev_type.metadata[:type_class] || prev_type}, #{type_defn.metadata[:type_class] || type_defn})")
+          end
+        when Class
+          if member.respond_to?(:graphql_definition)
+            graphql_member = member.graphql_definition
+            visit(schema, graphql_member, context_description)
+          else
+            raise GraphQL::Schema::InvalidTypeError.new("Unexpected traversal member: #{member} (#{member.class.name})")
+          end
+        else
+          message = "Unexpected schema traversal member: #{member} (#{member.class.name})"
+          raise GraphQL::Schema::InvalidTypeError.new(message)
+        end
+      end
+
+      def visit_fields(schema, type_defn)
+        type_defn.all_fields.each do |field_defn|
+          visit_field_on_type(schema, type_defn, field_defn)
+        end
+      end
+
+      def visit_field_on_type(schema, type_defn, field_defn, dynamic_field: false)
+        base_return_type = field_defn.type.unwrap
+        if base_return_type.is_a?(GraphQL::Schema::LateBoundType)
+          @late_bound_fields << [type_defn, field_defn, dynamic_field]
+          return
+        end
+        if dynamic_field
+          # Don't apply instrumentation to dynamic fields since they're shared constants
+          instrumented_field_defn = field_defn
+        else
+          instrumented_field_defn = @field_instrumenters.reduce(field_defn) do |defn, inst|
+            inst.instrument(type_defn, defn)
+          end
+          @instrumented_field_map[type_defn.name][instrumented_field_defn.name] = instrumented_field_defn
+        end
+        @type_reference_map[instrumented_field_defn.type.unwrap.name] << instrumented_field_defn
+        visit(schema, instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
+        instrumented_field_defn.arguments.each do |name, arg|
+          @type_reference_map[arg.type.unwrap.to_s] << arg
+          visit(schema, arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
+        end
+
+        # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
+        # to be passed to a resolver proc
+        GraphQL::Query::Arguments.construct_arguments_class(instrumented_field_defn)
+      end
+
+      def validate_type(member, context_description)
+        error_message = GraphQL::Schema::Validation.validate(member)
+        if error_message
+          raise GraphQL::Schema::InvalidTypeError.new("#{context_description} is invalid: #{error_message}")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/type_expression.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # @api private
+    module TypeExpression
+      # Fetch a type from a type map by its AST specification.
+      # Return `nil` if not found.
+      # @param type_owner [#get_type] A thing for looking up types by name
+      # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+      # @return [Class, GraphQL::Schema::NonNull, GraphQL::Schema:List]
+      def self.build_type(type_owner, ast_node)
+        case ast_node
+        when GraphQL::Language::Nodes::TypeName
+          type_owner.get_type(ast_node.name) # rubocop:disable Development/ContextIsPassedCop -- this is a `context` or `warden`, it's already query-aware
+        when GraphQL::Language::Nodes::NonNullType
+          ast_inner_type = ast_node.of_type
+          inner_type = build_type(type_owner, ast_inner_type)
+          wrap_type(inner_type, :to_non_null_type)
+        when GraphQL::Language::Nodes::ListType
+          ast_inner_type = ast_node.of_type
+          inner_type = build_type(type_owner, ast_inner_type)
+          wrap_type(inner_type, :to_list_type)
+        else
+          raise "Invariant: unexpected type from ast: #{ast_node.inspect}"
+        end
+      end
+
+      class << self
+        private
+
+        def wrap_type(type, wrapper_method)
+          if type.nil?
+            nil
+          elsif wrapper_method == :to_list_type || wrapper_method == :to_non_null_type
+            type.public_send(wrapper_method)
+          else
+            raise ArgumentError, "Unexpected wrapper method: #{wrapper_method.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/type_membership.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This class joins an object type to an abstract type (interface or union) of which
+    # it is a member.
+    class TypeMembership
+      # @return [Class<GraphQL::Schema::Object>]
+      attr_accessor :object_type
+
+      # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      attr_reader :abstract_type
+
+      # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
+      # or {Schema::Object.implements} (for interfaces).
+      #
+      # @param abstract_type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param object_type [Class<GraphQL::Schema::Object>]
+      # @param options [Hash] Any options passed to `.possible_types` or `.implements`
+      def initialize(abstract_type, object_type, **options)
+        @abstract_type = abstract_type
+        @object_type = object_type
+        @options = options
+      end
+
+      # @return [Boolean] if false, {#object_type} will be treated as _not_ a member of {#abstract_type}
+      def visible?(ctx)
+        warden = Warden.from_context(ctx)
+        (@object_type.respond_to?(:visible?) ? warden.visible_type?(@object_type, ctx) : true) &&
+          (@abstract_type.respond_to?(:visible?) ? warden.visible_type?(@abstract_type, ctx) : true)
+      end
+
+      def graphql_name
+        "#{@object_type.graphql_name}.#{@abstract_type.kind.interface? ? "implements" : "belongsTo" }.#{@abstract_type.graphql_name}"
+      end
+
+      def path
+        graphql_name
+      end
+
+      def inspect
+        "#<#{self.class} #{@object_type.inspect} => #{@abstract_type.inspect}>"
+      end
+
+      alias :type_class :itself
+    end
+  end
+end

data/lib/graphql/schema/union.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Union < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasUnresolvedTypeError
+
+      class << self
+        def inherited(child_class)
+          add_unresolved_type_error(child_class)
+          super
+        end
+
+        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
+          if types.any?
+            types.each do |t|
+              assert_valid_union_member(t)
+              type_memberships << type_membership_class.new(self, t, **options)
+            end
+          else
+            visible_types = []
+            warden = Warden.from_context(context)
+            type_memberships.each do |type_membership|
+              if warden.visible_type_membership?(type_membership, context)
+                visible_types << type_membership.object_type
+              end
+            end
+            visible_types
+          end
+        end
+
+        def all_possible_types
+          type_memberships.map(&:object_type)
+        end
+
+        def to_graphql
+          type_defn = GraphQL::UnionType.new
+          type_defn.name = graphql_name
+          type_defn.description = description
+          type_defn.ast_node = ast_node
+          type_defn.type_memberships = type_memberships
+          if respond_to?(:resolve_type)
+            type_defn.resolve_type = method(:resolve_type)
+          end
+          type_defn.metadata[:type_class] = self
+          type_defn
+        end
+
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
+          end
+        end
+
+        def kind
+          GraphQL::TypeKinds::UNION
+        end
+
+        def type_memberships
+          @type_memberships ||= []
+        end
+
+        # Update a type membership whose `.object_type` is a string or late-bound type
+        # so that the type membership's `.object_type` is the given `object_type`.
+        # (This is used for updating the union after the schema as lazily loaded the union member.)
+        # @api private
+        def assign_type_membership_object_type(object_type)
+          assert_valid_union_member(object_type)
+          type_memberships.each { |tm|
+            possible_type = tm.object_type
+            if possible_type.is_a?(String) && (possible_type == object_type.name)
+              # This is a match of Ruby class names, not graphql names,
+              # since strings are used to refer to constants.
+              tm.object_type = object_type
+            elsif possible_type.is_a?(LateBoundType) && possible_type.graphql_name == object_type.graphql_name
+              tm.object_type = object_type
+            end
+          }
+          nil
+        end
+
+        private
+
+        def assert_valid_union_member(type_defn)
+          if type_defn.is_a?(Module) && !type_defn.is_a?(Class)
+            # it's an interface type, defined as a module
+            raise ArgumentError, "Union possible_types can only be object types (not interface types), remove #{type_defn.graphql_name} (#{type_defn.inspect})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/unique_within_type.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'graphql/schema/base_64_bp'
+
+module GraphQL
+  class Schema
+    module UniqueWithinType
+      class << self
+        attr_accessor :default_id_separator
+      end
+      self.default_id_separator = "-"
+
+      module_function
+
+      # @param type_name [String]
+      # @param object_value [Any]
+      # @return [String] a unique, opaque ID generated as a function of the two inputs
+      def encode(type_name, object_value, separator: self.default_id_separator)
+        object_value_str = object_value.to_s
+
+        if type_name.include?(separator)
+          raise "encode(#{type_name}, #{object_value_str}) contains reserved characters `#{separator}` in the type name"
+        end
+
+        Base64.strict_encode64([type_name, object_value_str].join(separator))
+      end
+
+      # @param node_id [String] A unique ID generated by {.encode}
+      # @return [Array<(String, String)>] The type name & value passed to {.encode}
+      def decode(node_id, separator: self.default_id_separator)
+        GraphQL::Schema::Base64Encoder.decode(node_id).split(separator, 2)
+      end
+    end
+  end
+end