lighthouse-graphql 0.4.0 → 0.6.0

data/lib/lighthouse/directives/registry.rb

@@ -61,13 +61,17 @@ class Lighthouse::DirectiveRegistry
   # authorization, argument validation, then @cache (so a cache hit is still
   # authorized and validated), @clearCache (which acts once the resolver
   # succeeded), @event and @broadcast (likewise), and finally the data resolver (0).
+  # @throttle counts every call, before anything else runs; @async queues what is
+  # below @cache, once the request has authorized and validated the call.
   RESOLUTION_ORDER = {
+    'throttle' => 7,
     'convertEmptyStringsToNull' => 6,
     'guard' => 5, 'auth' => 5,
     'canFind' => 4, 'canModel' => 4, 'canQuery' => 4, 'canResolved' => 4, 'canRoot' => 4,
     'validator' => 3,
-    'cache' => 2,
-    'clearCache' => 1, 'event' => 1, 'broadcast' => 1
+    'cache' => 2, 'async' => 2,
+    'clearCache' => 1, 'event' => 1, 'broadcast' => 1,
+    'with' => 1, 'withCount' => 1, 'lazyLoad' => 1, 'globalId' => 1
   }.freeze
 
   def resolution_order(name)
@@ -164,6 +168,8 @@ class Lighthouse::DirectiveRegistry
     'rename' => :RenameDirectiveResolver,
     'method' => :MethodDirectiveResolver,
     'auth' => :AuthDirectiveResolver,
+    'hasManyThrough' => :HasManyDirectiveResolver,
+    'hasOneThrough' => :HasOneDirectiveResolver,
     'guard' => :GuardDirectiveResolver
   }.freeze
 
@@ -181,17 +187,15 @@ class Lighthouse::DirectiveRegistry
     CacheDirectiveResolver ClearCacheDirectiveResolver EventDirectiveResolver
     ValidatorDirectiveResolver ConvertEmptyStringsToNullDirectiveResolver
     SubscriptionDirectiveResolver BroadcastDirectiveResolver
+    WithDirectiveResolver WithCountDirectiveResolver LazyLoadDirectiveResolver
+    GlobalIdDirectiveResolver NamespacedDirectiveResolver ThrottleDirectiveResolver AsyncDirectiveResolver
   ].freeze
 
   # Argument-builder filter/sort directives.
-  ARG_BUILDERS = %i[Eq Neq In NotIn Like Where WhereKey OrderBy Trashed WithoutGlobalScopes].freeze
-
-  # Read by other directives rather than resolving anything themselves.
-  PASSIVE_DEFINITIONS = {
-    'spread' => 'directive @spread on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION',
-    'inject' => 'directive @inject(context: String!, name: String!) repeatable on FIELD_DEFINITION',
-    'cacheKey' => 'directive @cacheKey on FIELD_DEFINITION'
-  }.freeze
+  ARG_BUILDERS = %i[
+    Eq Neq In NotIn Like Where WhereKey OrderBy Trashed WithoutGlobalScopes
+    WhereNull WhereNotNull WhereBetween WhereNotBetween WhereJsonContains Scope Limit
+  ].freeze
 
   def register_defaults
     resolvers = Lighthouse::GraphQL::DirectiveResolvers
@@ -200,9 +204,14 @@ class Lighthouse::DirectiveRegistry
     ARG_BUILDERS.each { |constant| register(Lighthouse::GraphQL::Directives::Arguments.const_get(constant, false)) }
 
     # SDL manipulators run in registration order during the manipulation phase.
+    # @hide / @show first, so a removed field generates nothing; then @model,
+    # which names the model of fields @paginate then rewrites.
+    register_manipulator(Lighthouse::GraphQL::Directives::VisibilityDirective)
+    register_manipulator(Lighthouse::GraphQL::Directives::ModelDirective)
     register_manipulator(Lighthouse::GraphQL::Directives::PaginationManipulator)
     register_manipulator(Lighthouse::GraphQL::Directives::WhereConditionsDirective)
     register_manipulator(Lighthouse::GraphQL::Directives::SoftDeletesDirective)
+    register_manipulator(Lighthouse::GraphQL::Directives::NodeDirective)
 
     register_default_definitions
     self
@@ -213,17 +222,8 @@ class Lighthouse::DirectiveRegistry
   # SDL of the directives (and the types they refer to) that no registered
   # class contributes.
   def register_default_definitions
-    register_definition('builder', Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier::DEFINITION)
-    PASSIVE_DEFINITIONS.each { |name, definition| register_definition(name, definition) }
-    register_definition('cacheControl', Lighthouse::GraphQL::CacheControl::DEFINITION)
-    Lighthouse::GraphQL::CacheControl::TYPE_DEFINITIONS.each { |name, sdl| register_type_definition(name, sdl) }
-    register_definition('feature', Lighthouse::GraphQL::FeatureDirective::DEFINITION)
-    register_definition('complexity', Lighthouse::GraphQL::Complexity::DEFINITION)
-    Lighthouse::GraphQL::FeatureDirective::TYPE_DEFINITIONS.each { |name, sdl| register_type_definition(name, sdl) }
-    Lighthouse::GraphQL::Directives::WhereConditionsDirective::DEFINITIONS.each do |name, definition|
-      register_definition(name, definition)
-    end
-    Lighthouse::GraphQL::Directives::SoftDeletesDirective::DEFINITIONS.each { |name, definition| register_definition(name, definition) }
+    Lighthouse::GraphQL::Directives::Definitions.directives.each { |name, definition| register_definition(name, definition) }
+    Lighthouse::GraphQL::Directives::Definitions.types.each { |name, sdl| register_type_definition(name, sdl) }
   end
 
   def safe_definition(klass)

data/lib/lighthouse/directives/visibility_directive.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# @hide(env:) and @show(env:) — leave a field out of the schema in some
+# environments, as PHP Lighthouse's directives: @hide removes it in the ones
+# listed, @show keeps it only in those. The environment is Rails.env (see
+# Support::Environment); the SDL is rewritten before the schema is built.
+#
+#   type Query {
+#     debugInfo: String @show(env: ["development", "test"])
+#     legacyFeed: [Post!]! @hide(env: ["production"]) @all
+#   }
+class Lighthouse::GraphQL::Directives::VisibilityDirective
+  DEFINITIONS = {
+    'hide' => <<~GRAPHQL.chomp,
+      """
+      Excludes the annotated element from the schema conditionally.
+      """
+      directive @hide(
+        "Specify which environments must not use this field, e.g. [\\"production\\"]."
+        env: [String!]!
+      ) on FIELD_DEFINITION
+    GRAPHQL
+    'show' => <<~GRAPHQL.chomp
+      """
+      Includes the annotated element in the schema conditionally.
+      """
+      directive @show(
+        "Specify which environments may use this field, e.g. [\\"testing\\"]."
+        env: [String!]!
+      ) on FIELD_DEFINITION
+    GRAPHQL
+  }.freeze
+
+  FIELDS = [
+    ::GraphQL::Language::Nodes::ObjectTypeDefinition, ::GraphQL::Language::Nodes::ObjectTypeExtension,
+    ::GraphQL::Language::Nodes::InterfaceTypeDefinition, ::GraphQL::Language::Nodes::InterfaceTypeExtension
+  ].freeze
+
+  DECLARATION = /directive\s+@(hide|show)\b/
+  USAGE = /@(hide|show)\b/
+
+  def self.manipulate(sdl)
+    return sdl unless sdl.is_a?(String) && sdl.gsub(DECLARATION, '').match?(USAGE)
+
+    document = ::GraphQL::Language::Parser.parse(sdl)
+    env = Lighthouse::Support::Environment.current
+    ::GraphQL::Language::Printer.new.print(document.merge(definitions: document.definitions.map { |definition| visible_fields(definition, env) }))
+  rescue ::GraphQL::ParseError
+    sdl
+  end
+
+  def self.visible_fields(definition, env)
+    return definition unless FIELDS.any? { |kind| definition.is_a?(kind) }
+
+    definition.merge(fields: definition.fields.select { |field| visible?(field, env) })
+  end
+
+  def self.visible?(field, env)
+    field.directives.all? do |directive|
+      case directive.name
+      when 'hide' then environments(directive).exclude?(env)
+      when 'show' then environments(directive).include?(env)
+      else true
+      end
+    end
+  end
+
+  def self.environments(directive)
+    Array(directive.arguments.find { |argument| argument.name == 'env' }&.value).map(&:to_s)
+  end
+end

data/lib/lighthouse/enum_directive.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# @enum(value:) — the internal value of an enum value, as PHP Lighthouse's
+# directive: what a resolver gets for it in an argument, and what it answers
+# with in a result.
+#
+#   enum Role {
+#     ADMIN @enum(value: "admin")
+#     MEMBER @enum(value: "member")
+#   }
+#
+# `users(role: Role @eq)` then filters on "admin", and a User whose role is
+# "admin" answers ADMIN. Without the directive, a value is its own name.
+module Lighthouse::GraphQL::EnumDirective
+  DEFINITION = <<~GRAPHQL.chomp
+    """
+    Assign an internal value to an enum key.
+    When dealing with the Enum type in your code,
+    you will receive the defined value instead of the string key.
+    """
+    directive @enum(
+      "The internal value of the enum key."
+      value: Mixed
+    ) on ENUM_VALUE
+  GRAPHQL
+
+  TYPE_DEFINITIONS = { 'Mixed' => 'scalar Mixed' }.freeze
+
+  module_function
+
+  def apply(schema)
+    schema.types.each_value { |type| apply_to(type) if type.kind.enum? }
+  end
+
+  def apply_to(enum_type)
+    enum_type.values.each_value do |enum_value|
+      directive = (enum_value.ast_node&.directives || []).find { |d| d.name == 'enum' }
+      enum_value.value(Lighthouse::Support::DirectiveArgs.literal(directive, 'value')) if directive
+    end
+  end
+end

data/lib/lighthouse/field_resolver_stack.rb

@@ -4,21 +4,26 @@
 # DirectiveRegistry#resolution_order), so each wrapper decorates the ones
 # before it. Besides its directives, a field gets the conventional
 # Resolvers::/Mutations:: resolver when it is a root field with no resolving
-# directive, and argument validation when an input type it takes carries
-# @validator. The registry replaces a hardcoded `case dnode.name`: adding a
+# directive, the method of the type's class (Types::PostType) when another
+# type's field has none, and argument validation when an input type it takes
+# carries @validator. The registry replaces a hardcoded `case dnode.name`: adding a
 # directive is "register a class", not "edit the generator".
 module Lighthouse::GraphQL::FieldResolverStack
   module_function
 
   # `bases`: { root kind => base class } from the schema's base_types (ResolverBases).
-  def apply(type, field_def, directives, root_kind, bases: {})
+  # `type_class`: the class of a non-root type (Types::PostType), whose methods
+  # resolve its fields that have no resolving directive.
+  def apply(type, field_def, root_kind, bases: {}, type_class: nil)
+    directives = field_def.ast_node.directives || []
     opts = { root_kind: root_kind, bases: bases }
     steps = directive_steps(type, field_def, directives, opts)
-    steps << convention_step(type, field_def, root_kind, bases) if root_kind && !resolving_directive?(directives)
+    steps << limit_step(type, field_def, opts) if Lighthouse::GraphQL::DirectiveResolvers::LimitResolver.keyword(field_def)
+    steps << own_step(type, field_def, root_kind, bases, type_class) unless resolving_directive?(directives)
     steps << validator_step(type, field_def, opts) if input_validation?(field_def, directives)
-    steps << empty_strings_step(type, field_def, opts) if empty_string_conversion?(field_def, directives)
+    steps.concat(argument_steps(type, field_def, directives, opts))
 
-    steps.each_with_index.sort_by { |(order, _), index| [order, index] }.each { |(_, step), _| step.call }
+    steps.compact.each_with_index.sort_by { |(order, _), index| [order, index] }.each { |(_, step), _| step.call }
   end
 
   # [order, step] for every directive the registry has a resolver for.
@@ -50,6 +55,25 @@ module Lighthouse::GraphQL::FieldResolverStack
     [0, -> { resolver.define_resolver(type) }]
   end
 
+  # What resolves a field with no resolving directive: the method of the
+  # type's class (Types::QueryType#latest_posts too, as in graphql-ruby), else
+  # for a Query or Mutation field the conventional class. nil: the default reader.
+  def own_step(type, field_def, root_kind, bases, type_class)
+    return convention_step(type, field_def, root_kind, bases) if root_kind == :subscriptions
+
+    step = type_method_step(type, field_def, type_class, root: !root_kind.nil?) if type_class
+    step || (convention_step(type, field_def, root_kind, bases) if root_kind)
+  end
+
+  # Nothing to install when the class does not define the field's method: the
+  # field is read off the object.
+  # `root`: the class is the root type's, which the type is built on, not one found by name.
+  def type_method_step(type, field_def, type_class, root: false)
+    resolver = Lighthouse::GraphQL::DirectiveResolvers::TypeMethodResolver
+    method_name = resolver.method_for(type_class, field_def)
+    [0, -> { resolver.new(field_def, type, method_name, root ? type_class : nil).define_resolver(type) }] if method_name
+  end
+
   # An explicit @validator on the field already validates its arguments.
   def input_validation?(field_def, directives)
     directives.none? { |d| d.name == 'validator' } &&
@@ -69,6 +93,32 @@ module Lighthouse::GraphQL::FieldResolverStack
       Lighthouse::GraphQL::DirectiveResolvers::ConvertEmptyStringsToNullDirectiveResolver.implicit?(field_def)
   end
 
+  # The steps that change the arguments: empty strings to null and the rewriting
+  # directives (@globalId, @trim, @drop) outermost, so every wrapper sees them;
+  # the effectful ones (@hash, @bind, @upload) once @guard, @can* and @validator
+  # have let the call through (ArgumentTransformsResolver).
+  ARGUMENT_PHASES = { rewrite: 'convertEmptyStringsToNull', effects: 'cache' }.freeze
+
+  def argument_steps(type, field_def, directives, opts)
+    steps = []
+    steps << empty_strings_step(type, field_def, opts) if empty_string_conversion?(field_def, directives)
+    ARGUMENT_PHASES.each do |phase, alongside|
+      next unless Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver.transforms?(field_def, phase)
+
+      steps << transforms_step(type, field_def, opts.merge(phase: phase), Lighthouse::DirectiveRegistry.default.resolution_order(alongside))
+    end
+    steps
+  end
+
+  # Around whatever resolves the field, as @lazyLoad: the result is cut to the client's @limit.
+  def limit_step(type, field_def, opts)
+    [1, -> { Lighthouse::GraphQL::DirectiveResolvers::LimitResolver.new(field_def, type, nil, opts).define_resolver(type) }]
+  end
+
+  def transforms_step(type, field_def, opts, order)
+    [order, -> { Lighthouse::GraphQL::DirectiveResolvers::ArgumentTransformsResolver.new(field_def, type, nil, opts).define_resolver(type) }]
+  end
+
   def empty_strings_step(type, field_def, opts)
     resolver = Lighthouse::GraphQL::DirectiveResolvers::ConvertEmptyStringsToNullDirectiveResolver
     [Lighthouse::DirectiveRegistry.default.resolution_order(resolver.directive_name),

data/lib/lighthouse/generated_resolvers.rb

@@ -25,6 +25,7 @@ module Lighthouse::GraphQL::GeneratedResolvers
 
   # Generated resolvers take either (obj, args) or (obj, args, ctx).
   def invoke(resolver, obj, args, ctx)
+    args = take_lookahead(args, ctx)
     return resolver.call(obj, args) if resolver.parameters.length == 2
 
     resolver.call(obj, args, ctx)
@@ -37,13 +38,7 @@ module Lighthouse::GraphQL::GeneratedResolvers
   def install_dispatcher(schema)
     return unless schema.respond_to?(:definition_default_resolve=) && schema.respond_to?(:definition_default_resolve)
 
-    previous_default = schema.definition_default_resolve
-    schema.definition_default_resolve = proc do |type, field, obj, arguments, ctx|
-      resolver = generated_resolver(schema, type, field)
-      next invoke(resolver, obj, arguments, ctx) if resolver
-
-      previous_default.call(type, field, obj, arguments, ctx)
-    end
+    schema.definition_default_resolve = Lighthouse::GraphQL::DefaultResolveDispatcher.new(schema, schema.definition_default_resolve)
   end
 
   # Our generated resolver for `field`, looked up on the schema's own type
@@ -65,6 +60,16 @@ module Lighthouse::GraphQL::GeneratedResolvers
     end
   end
 
+  # The arguments without graphql-ruby's lookahead extra, which a field resolved
+  # by a class asks for (ResolveInfo.request_lookahead): it is kept in the
+  # field's scoped context, for its ResolveInfo, and no wrapper sees it.
+  def take_lookahead(args, ctx)
+    return args unless args.is_a?(Hash) && args[:lookahead].is_a?(::GraphQL::Execution::Lookahead)
+
+    ctx.scoped_set!(Lighthouse::GraphQL::ResolveInfo::LOOKAHEAD, args[:lookahead]) if ctx.respond_to?(:scoped_set!)
+    args.except(:lookahead)
+  end
+
   # GraphQL-Ruby's SDL builder defines `resolve_<field>` methods that call
   # the schema's `definition_default_resolve`. Override `resolve_<field>`
   # to delegate to our generated `resolve_field_<field>` when present, so
@@ -74,7 +79,7 @@ module Lighthouse::GraphQL::GeneratedResolvers
     return unless type.respond_to?(generated)
 
     type.define_singleton_method("resolve_#{field_def.name}") do |obj, arguments, ctx|
-      public_send(generated, obj, arguments, ctx)
+      public_send(generated, obj, Lighthouse::GraphQL::GeneratedResolvers.take_lookahead(arguments, ctx), ctx)
     end
   rescue StandardError
     # ignore override failures

data/lib/lighthouse/global_id.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+# Relay global ids, as PHP Lighthouse's Base64GlobalId writes them: the type
+# name and the id, joined by a colon, in base64 ("User:1" -> "VXNlcjox").
+# Config.global_id takes another object with `encode(type, id)` and
+# `decode(global_id)` -> [type, id], as PHP Lighthouse lets the GlobalId
+# contract be rebound.
+#
+# A schema that implements graphql-ruby's Relay ids, `id_from_object` and
+# `object_from_id` (graphql-ruby's install writes them, on Rails' GlobalID),
+# has one kind of global id: @globalId encodes an object's own id with
+# `id_from_object`, and decodes with `object_from_id`, as graphql-ruby's
+# Query.node and Node's `id` do.
+module Lighthouse::GraphQL::GlobalId
+  module_function
+
+  def encode(type, id)
+    Base64.strict_encode64("#{type}:#{id}")
+  end
+
+  def decode(global_id)
+    Base64.strict_decode64(global_id.to_s).split(':', 2)
+  rescue ArgumentError
+    []
+  end
+
+  # [type, id] for a global id a client sent, through the schema's
+  # object_from_id (schema_ids?) or Config.global_id; a
+  # GraphQL::ExecutionError when it is not one.
+  def decode!(global_id, context = nil)
+    type, id = schema_ids?(context&.schema) ? decode_object(global_id, context) : Lighthouse::Config.global_id.decode(global_id)
+    return [type, id] if type.present? && !id.nil?
+
+    raise ::GraphQL::ExecutionError, "#{global_id.inspect} is not a valid global id."
+  end
+
+  # The global id of `object`'s own id (`id`, what a field of `type` resolved)
+  # through the schema's id_from_object (schema_ids?); nil for anything else.
+  def encode_field(type, object, id, context)
+    return unless schema_ids?(context&.schema) && object.respond_to?(:id) && object.id.to_s == id.to_s
+
+    context.schema.id_from_object(object, type, context)
+  end
+
+  # Does `schema` define graphql-ruby's object_from_id (GraphQL::Schema's own raises)?
+  def schema_ids?(schema)
+    schema.respond_to?(:object_from_id) && schema.method(:object_from_id).owner != ::GraphQL::Schema.singleton_class
+  end
+
+  # [type, id] of the object the schema's object_from_id finds.
+  def decode_object(global_id, context)
+    object = context.schema.object_from_id(global_id, context)
+    object.nil? ? [] : [object.class.name.demodulize, object.id]
+  end
+end

data/lib/lighthouse/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module Lighthouse
   module GraphQL
-    VERSION = '0.4.0'
+    VERSION = '0.6.0'
   end
 end

data/lib/lighthouse/graphql_ruby_patches.rb

@@ -15,4 +15,49 @@ module Lighthouse::GraphQL
   # skip the fix rather than fail to load (explicit nulls then fail as before).
   builder = ::GraphQL::Schema::BuildFromDefinition.const_get(:Builder) if ::GraphQL::Schema::BuildFromDefinition.const_defined?(:Builder)
   builder.prepend(NullDirectiveArguments) if builder && (builder.method_defined?(:args_to_kwargs) || builder.private_method_defined?(:args_to_kwargs))
+
+  # graphql-ruby builds every SDL object type on base_types[:object], and every
+  # interface from base_types[:interface]. RootTypes builds a root type on the
+  # app's code-first one (Types::QueryType) instead, and takes the app's Node
+  # interface (Types::NodeType) as the SDL's Node.
+  module RootTypeBuilder
+    def build_object_type(definition, type_resolver, base_type)
+      root = Lighthouse::GraphQL::RootTypes.base_for(definition.name)
+      return super unless root
+
+      super(Lighthouse::GraphQL::RootTypes.definition_on(definition, root), type_resolver, root)
+    end
+
+    def build_interface_type(definition, type_resolver, base_type)
+      Lighthouse::GraphQL::RootTypes.base_for(definition.name) || super
+    end
+  end
+
+  # As above, a graphql-ruby release that reshapes the builder skips the hook:
+  # root types are then built on base_types[:object], as before.
+  if builder && %i[build_object_type build_interface_type].all? { |name| builder.method_defined?(name) || builder.private_method_defined?(name) }
+    builder.prepend(RootTypeBuilder)
+  end
+
+  # The app's schema class inherits Lighthouse's (`class AppSchema <
+  # get_schema(...)`), so its Subscription root type is the parent's. A
+  # subscriptions backend the subclass `use`s (ActionCableSubscriptions) then
+  # finds no root type of the subclass's own, and graphql-ruby adds its
+  # subscription extension to no field. Look the root type up through the
+  # parent too. Extended onto the schemas Lighthouse builds (SchemaGenerator).
+  module InheritedSubscriptionRoot
+    def add_subscription_extension_if_necessary
+      return super if @subscription_object.is_a?(Class) || !defined?(::GraphQL::Subscriptions::DefaultSubscriptionResolveExtension)
+      return unless inherited_subscription_root_pending?
+
+      @subscription_extension_added = true
+      extension = ::GraphQL::Subscriptions::DefaultSubscriptionResolveExtension
+      subscription.all_field_definitions.each { |field| field.extension(extension) unless field.extensions.any?(extension) }
+    end
+
+    # A backend, a root type from the parent, and no extension added yet.
+    def inherited_subscription_root_pending?
+      !defined?(@subscription_extension_added) && subscription.is_a?(Class) && !subscriptions.nil?
+    end
+  end
 end

data/lib/lighthouse/multipart_request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# The GraphQL multipart request specification
+# (https://github.com/jaydenseric/graphql-multipart-request-spec), which file
+# uploads use: a multipart form with `operations` (the JSON operation, or a
+# batch of them), `map` (each file's form key => the paths in `operations` it
+# goes to, e.g. { "0": ["variables.avatar"] }) and the files. The controller
+# concern reads it into the operation(s), with every file in place.
+module Lighthouse::GraphQL::MultipartRequest
+  module_function
+
+  # The operation (a Hash) or batch (an Array), with the files in place; nil
+  # when the request is not a multipart one.
+  def operations(params)
+    raw = param(params, 'operations')
+    return unless raw
+
+    operations = parse(raw)
+    parse(param(params, 'map') || '{}').each do |key, paths|
+      Array(paths).each { |path| place(operations, path.to_s.split('.'), param(params, key)) }
+    end
+    operations
+  end
+
+  def param(params, key)
+    params[key.to_s] || params[key.to_sym]
+  end
+
+  def parse(value)
+    value = value.to_unsafe_h if value.respond_to?(:to_unsafe_h)
+    value.is_a?(String) ? JSON.parse(value) : value
+  end
+
+  def place(target, segments, file)
+    *parents, last = segments
+    container = parents.reduce(target) { |node, segment| node.is_a?(Array) ? node[Integer(segment)] : node[segment] }
+    raise ArgumentError, "The multipart map names a path that is not in the operations: #{segments.join('.')}" unless container
+
+    container.is_a?(Array) ? container[Integer(last)] = file : container[last] = file
+  end
+end

data/lib/lighthouse/node_registry.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Resolves Relay's `Query.node(id:)`, which @node adds, as PHP Lighthouse's
+# NodeRegistry: the id is decoded into a type and an id, and the type must be
+# one with @node. Its object comes from, in order:
+#
+# - `@node(resolver: "Class@method")`: the class (method `call` without `@`),
+#   looked up as @field looks a class up on a type, called with the id and the
+#   context;
+# - `@node(model: "Name")`, or else the type's @model, or else the model named
+#   after the type:
+#   the record with that primary key, batched across every `node` in the query.
+#
+# It also tells the Node interface which type each object is (resolve_type):
+# `node` hands back the object with the type its id named, so a `resolver:` may
+# return any object, a Hash included, and one record may be two node types.
+class Lighthouse::GraphQL::NodeRegistry
+  # What `node` returns: the object, and the type its global id named.
+  Found = Struct.new(:type, :object)
+
+  def self.resolve(_root, args, context, _info = nil)
+    type_name, id = args[:id]
+    type = context.schema.get_type(type_name.to_s)
+    raise ::GraphQL::ExecutionError, "[#{type_name}] is not a type that can be resolved by node." unless node_type?(type)
+
+    object = find(type, id, context)
+    object.nil? ? nil : Found.new(type, object)
+  end
+
+  # [type, object] for what `node` found; nil leaves any other Node value to the default.
+  def self.resolve_type(object, _context)
+    [object.type, object.object] if object.is_a?(Found)
+  end
+
+  def self.node_type?(type)
+    type&.kind&.object? && !directive(type).nil?
+  end
+
+  def self.directive(type)
+    (type.ast_node&.directives || []).find { |d| d.name == 'node' }
+  end
+
+  def self.find(type, id, context)
+    node = directive(type)
+    resolver = Lighthouse::Support::DirectiveArgs.literal(node, 'resolver')
+    return call_resolver(resolver, id, context) if resolver
+
+    model = model_for(type, Lighthouse::Support::DirectiveArgs.literal(node, 'model'))
+    raise Lighthouse::DefinitionError, "@node on #{type.graphql_name} finds no model: give it model: or resolver:." unless model
+
+    context.dataloader.with(::GraphQL::Dataloader::ActiveRecordSource, model).load(model.type_for_attribute(model.primary_key).cast(id))
+  end
+
+  def self.call_resolver(reference, id, context)
+    class_name, method = Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver.reference(reference)
+    klass = Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver.lookup(class_name, nil)
+    raise Lighthouse::DefinitionError, "@node(resolver: #{reference.inspect}) names no class." unless klass
+
+    receiver = Lighthouse::GraphQL::ResolverDispatch.callable_receiver(klass, method || :call)
+    receiver.public_send(method || :call, id, context)
+  end
+
+  def self.model_for(type, name)
+    return Lighthouse::Support::ModelResolver.constantize(name) if name
+
+    Lighthouse::GraphQL::Directives::ModelDirective.model_for(type)
+  end
+end

data/lib/lighthouse/pagination.rb

@@ -110,6 +110,9 @@ module Lighthouse::GraphQL::Pagination
       @items = items
     end
 
+    # The records on the page, for @lazyLoad.
+    attr_reader :items
+
     def marshal_dump
       [info, @items]
     end