lighthouse-graphql 0.4.0 → 0.6.0

data/lib/lighthouse/support/preload.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Eager loading for @with and @lazyLoad: ActiveRecord's preloader, over records
+# of any classes, with relation names as PHP Lighthouse writes them
+# ("comments.author" is comments, and each comment's author).
+module Lighthouse::Support::Preload
+  module_function
+
+  # ["comments.author", "tags"] -> [{ comments: :author }, :tags]
+  def associations(names)
+    Array(names).map do |name|
+      *path, last = name.to_s.split('.').map(&:to_sym)
+      path.reverse.reduce(last) { |nested, segment| { segment => nested } }
+    end
+  end
+
+  # Load `associations` into `records`, grouped by class; a class that has no
+  # such association is left alone. `scopes` (model scope names) narrow the
+  # loaded records, as Laravel's constrained eager loads do.
+  def records(records, associations, scopes = [])
+    records.grep(::ActiveRecord::Base).group_by(&:class).each do |klass, group|
+      own = associations.select { |association| klass.reflect_on_association(root(association)) }
+      own.each { |association| preload(klass, group, association, scopes) }
+    end
+    records
+  end
+
+  def root(association)
+    association.is_a?(Hash) ? association.keys.first : association
+  end
+
+  def preload(klass, records, association, scopes)
+    scope = scoped(klass, association, scopes)
+    preloader = ::ActiveRecord::Associations::Preloader
+    if preloader.method_defined?(:call)
+      preloader.new(records: records, associations: association, scope: scope).call # Rails >= 7
+    else
+      preloader.new.preload(records, association, scope)                             # Rails 6
+    end
+  end
+
+  # The scopes applied to the association's model, or nil for none.
+  def scoped(klass, association, scopes)
+    return if scopes.blank?
+
+    target = klass.reflect_on_association(root(association)).klass
+    scopes.reduce(target.all) { |relation, scope| relation.public_send(scope) }
+  end
+end

data/lib/lighthouse/type.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+# Hands a graphql-ruby type class to Lighthouse, as `include
+# Lighthouse::GraphQL::Subscription` does a subscription. The class keeps
+# graphql-ruby's folder structure and naming (app/graphql/types/post_type.rb,
+# Types::PostType for the SDL's Post type) and base classes, and does for the
+# SDL type of its name what it does in a graphql-ruby schema:
+#
+#   class Types::PostType < Types::BaseObject              # an object type
+#     include Lighthouse::GraphQL::Type
+#
+#     def reading_time = { words: object.body.to_s.split.size }
+#   end
+#
+#   class Types::SearchResultType < Types::BaseUnion       # a union
+#     include Lighthouse::GraphQL::Type
+#
+#     def self.resolve_type(object, context) = object.is_a?(Post) ? 'Post' : 'User'
+#   end
+#
+#   module Types::NamedType                                 # an interface
+#     include Types::BaseInterface
+#     include Lighthouse::GraphQL::Type
+#
+#     definition_methods do
+#       def resolve_type(object, context) = ...
+#     end
+#   end
+#
+#   class Types::DateTimeType < Types::BaseScalar           # a scalar
+#     include Lighthouse::GraphQL::Type
+#
+#     def self.coerce_input(value, context) = Time.iso8601(value)
+#     def self.coerce_result(value, context) = value.iso8601
+#   end
+#
+# An object type's methods resolve its fields that have no resolving
+# directive, with graphql-ruby's `object` (the parent), `context`, the
+# `dataload*` helpers, and the field's arguments as snake_case keywords. A
+# union's or interface's `resolve_type` picks the object type of a value (a
+# type name, or a type class such as Types::PostType). A scalar's
+# `coerce_input` / `coerce_result` convert its values. The SDL still declares
+# the types and their fields: the class only lends its behaviour, so `field`
+# declarations in it are ignored, and an object type's `authorized?` does not run.
+#
+# The model an object type resolves is the SDL's to say, with @model(class:).
+#
+# A Types::<Name>Type that does not include the concern is not Lighthouse's,
+# and is left alone.
+module Lighthouse::GraphQL::Type
+  extend ActiveSupport::Concern
+
+  # The kinds of graphql-ruby class the concern can be included in.
+  KINDS = {
+    object: ::GraphQL::Schema::Object,
+    union: ::GraphQL::Schema::Union,
+    scalar: ::GraphQL::Schema::Scalar,
+    interface: ::GraphQL::Schema::Interface
+  }.freeze
+
+  # :object, :union, :scalar or :interface for a graphql-ruby type class or
+  # interface module; nil for anything else.
+  def self.kind_of(mod)
+    return :interface if !mod.is_a?(Class) && mod.is_a?(Module) && mod.include?(KINDS[:interface])
+    return unless mod.is_a?(Class)
+
+    %i[object union scalar].find { |kind| mod < KINDS[kind] }
+  end
+
+  # The class of the SDL type `type_name` (`Types::PostType` for `Post`) in
+  # Config.namespaces[:types], when it includes the concern; nil otherwise. The
+  # class must be of the same `kind` as the SDL type.
+  def self.class_for(type_name, kind)
+    klass = Lighthouse::Support::ModelResolver.constantize("#{type_name}Type", namespaces: Lighthouse::Config.namespaces[:types],
+                                                                               fallback: false)
+    return unless klass.is_a?(Module) && klass.include?(self) && kind_of(klass)
+    return klass if kind_of(klass) == kind
+
+    raise Lighthouse::DefinitionError, "#{klass} is a type class of kind #{kind_of(klass)}, but #{type_name} is of kind #{kind} in the schema."
+  end
+
+  # What the SDL's types take from their classes and directives, once the
+  # schema is built: every @model names a model (ModelDirective), every @union /
+  # @interface class exists and every type class matches its kind and base
+  # (TypeResolution), and every scalar with a class reads and writes its values
+  # through it (ScalarCoercion). `bases`: the schema's base_types, by kind.
+  def self.apply(schema, bases = {})
+    Lighthouse::GraphQL::Directives::ModelDirective.validate!(schema)
+    Lighthouse::GraphQL::TypeResolution.validate!(schema, bases)
+    Lighthouse::GraphQL::ScalarCoercion.apply(schema, bases[:scalar])
+    Lighthouse::GraphQL::EnumDirective.apply(schema)
+  end
+
+  included do
+    unless Lighthouse::GraphQL::Type.kind_of(self)
+      raise Lighthouse::DefinitionError,
+            "#{self} includes Lighthouse::GraphQL::Type, which is for graphql-ruby types: a subclass of GraphQL::Schema::Object, " \
+            'Union or Scalar, or a module including GraphQL::Schema::Interface (class Types::PostType < Types::BaseObject).'
+    end
+  end
+end

data/lib/lighthouse/type_resolution.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+# Which object type a value of a union or interface is: graphql-ruby asks the
+# schema (its `resolve_type`) each time a field returns one. In order:
+#
+# 1. `@union(resolveType: "Name")` / `@interface(resolveType: "Name")` on the
+#    SDL type names a class, looked up in Config.namespaces[:types] (nested
+#    names too) and then as written, with `resolve_type(object, context)` or
+#    `call(object, context)`. PHP Lighthouse's directives.
+# 2. Its type class, Types::<Name>Type including Lighthouse::GraphQL::Type: a
+#    union's `self.resolve_type(object, context)`, or an interface's
+#    `definition_methods { def resolve_type(object, context) }`, as in graphql-ruby.
+# 3. The default, as PHP Lighthouse's: a Hash's `__typename`; else the type
+#    named after the object's class, or one of its superclasses (STI); else the
+#    type whose @model names the object's model (`type Article @model(class: "Post")`).
+#
+# A class returns a type name, the SDL type, or a type class (Types::PostType),
+# which stands for the SDL type of its graphql_name; or, as graphql-ruby allows,
+# [type, value] to resolve the type's fields on `value`. nil falls through to the
+# next step. A value no step resolves, or one resolved to a type the union or
+# interface does not include, raises Lighthouse::DefinitionError.
+module Lighthouse::GraphQL::TypeResolution
+  DEFINITIONS = {
+    'union' => <<~GRAPHQL.chomp,
+      """
+      The class that picks the object type of this union's values: `resolve_type(object, context)`
+      or `call(object, context)`, returning a type name or a type class.
+      """
+      directive @union(resolveType: String!) on UNION
+    GRAPHQL
+    'interface' => <<~GRAPHQL.chomp
+      """
+      The class that picks the object type of this interface's values: `resolve_type(object, context)`
+      or `call(object, context)`, returning a type name or a type class.
+      """
+      directive @interface(resolveType: String!) on INTERFACE
+    GRAPHQL
+  }.freeze
+
+  DIRECTIVES = DEFINITIONS.keys.freeze
+
+  module_function
+
+  # The object type, or [object type, value] when a class answered with a
+  # value to resolve the fields on instead of `object` (as graphql-ruby allows).
+  def resolve(schema, abstract_type, object, context)
+    answer = custom(abstract_type, object, context)
+    answer, value = answer if answer.is_a?(Array) && answer.size == 2
+    type = type_named(schema, answer) || default(schema, abstract_type, object)
+    unless type && schema.possible_types(abstract_type).include?(type)
+      raise Lighthouse::DefinitionError, unresolved_message(schema, abstract_type, object, type)
+    end
+
+    value.nil? ? type : [type, value]
+  end
+
+  # What the directive's class or the type class says, or nil.
+  def custom(abstract_type, object, context)
+    resolver = directive_class(abstract_type) || type_class(abstract_type)
+    return unless resolver
+
+    resolver.respond_to?(:resolve_type) ? resolver.resolve_type(object, context) : resolver.call(object, context)
+  end
+
+  def default(schema, abstract_type, object)
+    candidates = schema.possible_types(abstract_type)
+    by_name = candidates.index_by(&:graphql_name)
+
+    typename = typename_of(object)
+    return by_name[typename] if typename
+
+    class_chain(object.class).each { |name| return by_name[name] if by_name.key?(name) }
+    candidates.find { |type| model_of(type)&.then { |model| object.is_a?(model) } }
+  end
+
+  # Fail at build time, not on the first query: every class a @union /
+  # @interface names exists and answers, and every type class matches its kind.
+  # `bases`: the schema's base_types, by kind, that type classes inherit from.
+  def validate!(schema, bases = {})
+    schema.types.each_value do |type|
+      next unless type.kind.union? || type.kind.interface?
+
+      directive_class(type)
+      kind = type.kind.union? ? :union : :interface
+      klass = Lighthouse::GraphQL::Type.class_for(type.graphql_name, kind)
+      Lighthouse::GraphQL::ResolverBases.check!(klass, bases[kind], "the #{type.graphql_name} #{kind}") if klass
+    end
+  end
+
+  # The SDL type a resolver's answer stands for: a name, a type, or a type class.
+  def type_named(schema, answer)
+    return if answer.nil?
+
+    schema.get_type(answer.respond_to?(:graphql_name) ? answer.graphql_name : answer.to_s)
+  end
+
+  def directive_class(abstract_type)
+    directive, name = resolve_type_directive(abstract_type)
+    return unless name
+
+    klass = Lighthouse::Support::ModelResolver.constantize(name, namespaces: Lighthouse::Config.namespaces[:types], nested: true)
+    return klass if klass.respond_to?(:resolve_type) || klass.respond_to?(:call)
+
+    raise Lighthouse::DefinitionError,
+          "@#{directive.name}(resolveType: #{name.inspect}) on #{abstract_type.graphql_name} names no class with resolve_type(object, context) " \
+          'or call(object, context).'
+  end
+
+  # The @union / @interface on the type and the class name it gives, or nil.
+  def resolve_type_directive(abstract_type)
+    directive = (abstract_type.ast_node&.directives || []).find { |d| DIRECTIVES.include?(d.name) }
+    [directive, Lighthouse::Support::DirectiveArgs.literal(directive, 'resolveType')] if directive
+  end
+
+  def type_class(abstract_type)
+    kind = abstract_type.kind.union? ? :union : :interface
+    klass = Lighthouse::GraphQL::Type.class_for(abstract_type.graphql_name, kind)
+    klass if klass.respond_to?(:resolve_type)
+  end
+
+  def typename_of(object)
+    return unless object.is_a?(Hash)
+
+    (object['__typename'] || object[:__typename])&.to_s
+  end
+
+  # Admin, User, ApplicationRecord, ... for an Admin < User record.
+  def class_chain(klass)
+    names = []
+    while klass
+      names << klass.name.demodulize if klass.name
+      klass = klass.superclass
+    end
+    names
+  end
+
+  def model_of(type)
+    Lighthouse::GraphQL::Directives::ModelDirective.declared_model(type)
+  end
+
+  def unresolved_message(schema, abstract_type, object, type)
+    possible = schema.possible_types(abstract_type).map(&:graphql_name).join(' | ')
+    kind = abstract_type.kind.union? ? 'union' : 'interface'
+    return "#{abstract_type.graphql_name} resolved a #{object.class} to #{type.graphql_name}, which is not one of its types (#{possible})." if type
+
+    "Lighthouse could not tell the type of a #{object.class} in the #{kind} #{abstract_type.graphql_name} (#{possible}): " \
+      "name a type after its class, map one to it with @model(class: \"#{object.class}\"), or resolve it in " \
+      "Types::#{abstract_type.graphql_name}Type.resolve_type or with @#{kind}(resolveType:)."
+  end
+end

data/lib/lighthouse/upload.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# The `Upload` scalar: a file a client sends with a multipart request (the
+# GraphQL multipart request specification, MultipartRequest). `scalar Upload`
+# in the SDL reads its values through it unless the SDL or a type class names
+# another class. The resolver gets the uploaded file (an
+# ActionDispatch::Http::UploadedFile in Rails): attach it to a model
+# (`avatar: Upload` with @create on a model with has_one_attached :avatar), or
+# store it with @upload.
+class Lighthouse::GraphQL::Upload < GraphQL::Schema::Scalar
+  graphql_name 'Upload'
+
+  def self.coerce_input(value, _context)
+    return value if file?(value)
+
+    raise ::GraphQL::CoercionError,
+          'Could not get uploaded file, be sure to conform to GraphQL multipart request specification: ' \
+          "https://github.com/jaydenseric/graphql-multipart-request-spec. Instead got: #{value.inspect}."
+  end
+
+  def self.coerce_result(_value, _context)
+    raise ::GraphQL::Error, '"Upload" cannot be serialized, it can only be used as an argument.'
+  end
+
+  def self.file?(value)
+    value.respond_to?(:read) && (value.respond_to?(:original_filename) || value.respond_to?(:path))
+  end
+end

data/lib/lighthouse/upload_store.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Where @upload puts a file, as PHP Lighthouse's @upload puts it on one of the
+# app's Laravel disks: an ActiveStorage blob on one of the app's services
+# (config/storage.yml). `disk` names the service (config.active_storage.service
+# without it), `path` prefixes the blob's key. ActiveStorage sets visibility per
+# service (`public: true` in storage.yml), not per file, so `public` must agree
+# with the service's: the schema never says a file is private that anyone can
+# read, or public that no one can. The argument then holds the blob's signed id,
+# which a has_one_attached / has_many_attached attribute attaches (where Laravel
+# hands the stored path, for a model to keep). To store files elsewhere, declare
+# an ActiveStorage service for it, as a Laravel app declares a disk.
+module Lighthouse::GraphQL::UploadStore
+  module_function
+
+  def call(file, argument:, disk: nil, path: nil, public: nil)
+    unless defined?(::ActiveStorage::Blob)
+      raise Lighthouse::DefinitionError, '@upload stores files with ActiveStorage: install it (bin/rails active_storage:install).'
+    end
+    unless Lighthouse::GraphQL::Upload.file?(file)
+      raise Lighthouse::DefinitionError, "Expected argument `#{argument}` to be an uploaded file (Upload)."
+    end
+
+    service = service(argument, disk, public == true)
+    file.rewind if file.respond_to?(:rewind) # a @validator, or another argument the multipart map sent it to, may have read it
+    ::ActiveStorage::Blob.create_and_upload!(
+      io: file, filename: filename(file), content_type: file.try(:content_type), key: key(path), service_name: service.name
+    ).signed_id
+  end
+
+  # The service `disk` names, or the default one, checked to be as public as asked.
+  def service(argument, disk, public)
+    service = disk ? ::ActiveStorage::Blob.services.fetch(disk) : ::ActiveStorage::Blob.service
+    return service if (service.public? == true) == public
+
+    raise Lighthouse::DefinitionError, visibility_mismatch(argument, service.name, public)
+  rescue KeyError => e
+    raise Lighthouse::DefinitionError, "@upload on `#{argument}`: #{e.message}"
+  end
+
+  def visibility_mismatch(argument, service_name, public)
+    fix = public ? 'name a public one (public: true in config/storage.yml) with disk:' : 'pass public: true, or name a private one with disk:'
+    "@upload#{'(public: true)' if public} on `#{argument}` stores on the ActiveStorage service `#{service_name}`, " \
+      "which is #{'not ' if public}public: #{fix}."
+  end
+
+  def filename(file)
+    file.respond_to?(:original_filename) ? file.original_filename : File.basename(file.path)
+  end
+
+  # `path`'s directory, then a fresh token, as Laravel's `storeAs(path, hashName)`;
+  # under the root ("/", the default), ActiveStorage's own key.
+  def key(path)
+    prefix = path.to_s.delete_prefix('/').delete_suffix('/')
+    prefix.empty? ? nil : "#{prefix}/#{::ActiveStorage::Blob.generate_unique_secure_token}"
+  end
+end

data/sig/lighthouse/directives.rbs

@@ -104,8 +104,9 @@ module Lighthouse
         # Install the field's resolver on `target_type_class` (a graphql-ruby type class).
         def define_resolver: (untyped target_type_class) -> untyped
 
-        def apply_where_filters: (relation relation, untyped args) -> relation
-        def apply_arg_builders: (relation relation, arguments args_h) -> relation
+        # `ctx`: the query's context, which @builder on an argument receives.
+        def apply_where_filters: (relation relation, untyped args, ?context? ctx) -> relation
+        def apply_arg_builders: (relation relation, arguments args_h, ?context? ctx) -> relation
         def extract_relation_name_from_directive: (untyped arg_node) -> String?
         def constantize_model: (String? name) -> Class?
         def apply_scopes: (relation relation) -> relation

data/sig/lighthouse.rbs

@@ -39,6 +39,12 @@ module Lighthouse
     def call: (StandardError error, context? context) -> void
   end
 
+  # Config.global_id: encodes and decodes Relay global ids (@globalId, @node).
+  interface _GlobalId
+    def encode: (String type, untyped id) -> String
+    def decode: (String global_id) -> Array[String]
+  end
+
   # Config.authenticated_user and Config.policy_user: the user of a request.
   interface _UserReader
     def call: (context? context) -> untyped
@@ -100,8 +106,6 @@ module Lighthouse
     def self.directive_map: () -> Hash[untyped, untyped]
 
     # An ActiveSupport::Cache::Store; Rails.cache by default.
-    def self.cache_store: () -> untyped
-    def self.cache_store=: (untyped store) -> untyped
 
     def self.transactional_mutations: () -> bool
     def self.transactional_mutations=: (bool? enabled) -> bool?
@@ -132,6 +136,10 @@ module Lighthouse
     def self.convert_empty_strings_to_null: () -> bool
     def self.convert_empty_strings_to_null=: (bool? enabled) -> bool?
 
+    def self.global_id: () -> _GlobalId
+    def self.global_id=: (_GlobalId? codec) -> _GlobalId?
+
+
     # Whether @broadcast triggers in an ActiveJob (Lighthouse::GraphQL::BroadcastJob)
     # unless the directive says shouldQueue; and the job's queue (nil: ActiveJob's default).
     def self.queue_broadcasts: () -> bool

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lighthouse-graphql
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Vaz Innovation
@@ -62,29 +62,32 @@ files:
 - docs/events.md
 - docs/federation.md
 - docs/filtering-and-ordering.md
+- docs/generators.md
 - docs/getting-started.md
 - docs/motivation.md
 - docs/mutations.md
 - docs/performance.md
 - docs/relationships.md
+- docs/relay.md
 - docs/resolvers.md
 - docs/security.md
 - docs/subscriptions.md
+- docs/types.md
+- docs/uploads.md
 - docs/validation.md
 - lib/generators/lighthouse/base_classes.rb
 - lib/generators/lighthouse/builder_generator.rb
 - lib/generators/lighthouse/class_generator.rb
+- lib/generators/lighthouse/install/graphql_ruby_install.rb
 - lib/generators/lighthouse/install/install_generator.rb
 - lib/generators/lighthouse/install/templates/graphql.config.yml.tt
 - lib/generators/lighthouse/install/templates/graphql_controller.rb.tt
 - lib/generators/lighthouse/install/templates/initializer.rb.tt
 - lib/generators/lighthouse/install/templates/schema.graphql.tt
-- lib/generators/lighthouse/install/templates/schema.rb.tt
-- lib/generators/lighthouse/mutation_generator.rb
-- lib/generators/lighthouse/query_generator.rb
 - lib/generators/lighthouse/subscription_generator.rb
 - lib/generators/lighthouse/validator_generator.rb
 - lib/lighthouse-graphql.rb
+- lib/lighthouse/async_mutation_job.rb
 - lib/lighthouse/broadcast_job.rb
 - lib/lighthouse/broadcasting.rb
 - lib/lighthouse/cache_control.rb
@@ -101,11 +104,17 @@ files:
 - lib/lighthouse/controller.rb
 - lib/lighthouse/dataloader_sources/association_loader.rb
 - lib/lighthouse/dataloader_sources/model_loader.rb
+- lib/lighthouse/dataloader_sources/preload_loader.rb
 - lib/lighthouse/dataloader_sources/relation_count_loader.rb
+- lib/lighthouse/dataloader_sources/relation_counts_loader.rb
 - lib/lighthouse/dataloader_sources/relation_page_loader.rb
+- lib/lighthouse/default_resolve_dispatcher.rb
 - lib/lighthouse/directive_resolvers/aggregate_resolver.rb
 - lib/lighthouse/directive_resolvers/all_resolver.rb
+- lib/lighthouse/directive_resolvers/argument_binding.rb
+- lib/lighthouse/directive_resolvers/argument_transforms_resolver.rb
 - lib/lighthouse/directive_resolvers/association_resolvers.rb
+- lib/lighthouse/directive_resolvers/async_resolver.rb
 - lib/lighthouse/directive_resolvers/auth_resolver.rb
 - lib/lighthouse/directive_resolvers/base.rb
 - lib/lighthouse/directive_resolvers/broadcast_resolver.rb
@@ -119,25 +128,39 @@ files:
 - lib/lighthouse/directive_resolvers/field_resolver.rb
 - lib/lighthouse/directive_resolvers/find_resolver.rb
 - lib/lighthouse/directive_resolvers/first_resolver.rb
+- lib/lighthouse/directive_resolvers/global_id_resolver.rb
 - lib/lighthouse/directive_resolvers/guard_resolver.rb
+- lib/lighthouse/directive_resolvers/lazy_load_resolver.rb
+- lib/lighthouse/directive_resolvers/limit_resolver.rb
 - lib/lighthouse/directive_resolvers/method_resolver.rb
 - lib/lighthouse/directive_resolvers/model_mutation_resolver.rb
+- lib/lighthouse/directive_resolvers/namespaced_resolver.rb
 - lib/lighthouse/directive_resolvers/paginate_resolver.rb
 - lib/lighthouse/directive_resolvers/rename_resolver.rb
 - lib/lighthouse/directive_resolvers/resolution.rb
 - lib/lighthouse/directive_resolvers/soft_delete_resolvers.rb
 - lib/lighthouse/directive_resolvers/subscription_resolver.rb
+- lib/lighthouse/directive_resolvers/throttle_resolver.rb
+- lib/lighthouse/directive_resolvers/type_method_resolver.rb
 - lib/lighthouse/directive_resolvers/validator_resolver.rb
 - lib/lighthouse/directive_resolvers/where_conditions_applier.rb
+- lib/lighthouse/directive_resolvers/with_count_resolver.rb
+- lib/lighthouse/directive_resolvers/with_resolver.rb
 - lib/lighthouse/directives/arguments/base.rb
 - lib/lighthouse/directives/arguments/filters.rb
+- lib/lighthouse/directives/arguments/more_filters.rb
 - lib/lighthouse/directives/arguments/order_by.rb
 - lib/lighthouse/directives/arguments/soft_deletes.rb
+- lib/lighthouse/directives/definitions.rb
+- lib/lighthouse/directives/model_directive.rb
+- lib/lighthouse/directives/node_directive.rb
 - lib/lighthouse/directives/pagination_info_types.rb
 - lib/lighthouse/directives/pagination_manipulator.rb
 - lib/lighthouse/directives/registry.rb
 - lib/lighthouse/directives/soft_deletes_directive.rb
+- lib/lighthouse/directives/visibility_directive.rb
 - lib/lighthouse/directives/where_conditions_directive.rb
+- lib/lighthouse/enum_directive.rb
 - lib/lighthouse/errors.rb
 - lib/lighthouse/events.rb
 - lib/lighthouse/events/execution_trace.rb
@@ -147,10 +170,12 @@ files:
 - lib/lighthouse/federation_directives.rb
 - lib/lighthouse/field_resolver_stack.rb
 - lib/lighthouse/generated_resolvers.rb
+- lib/lighthouse/global_id.rb
 - lib/lighthouse/graphql.rb
 - lib/lighthouse/graphql/version.rb
 - lib/lighthouse/graphql_ruby_patches.rb
 - lib/lighthouse/ide_helper.rb
+- lib/lighthouse/multipart_request.rb
 - lib/lighthouse/namespaces.rb
 - lib/lighthouse/nested_mutations.rb
 - lib/lighthouse/nested_mutations/belongs_to_operations.rb
@@ -158,6 +183,7 @@ files:
 - lib/lighthouse/nested_mutations/has_operations.rb
 - lib/lighthouse/nested_mutations/many_to_many_operations.rb
 - lib/lighthouse/nested_mutations/partitioner.rb
+- lib/lighthouse/node_registry.rb
 - lib/lighthouse/pagination.rb
 - lib/lighthouse/persisted_queries.rb
 - lib/lighthouse/persisted_queries/batch.rb
@@ -165,8 +191,12 @@ files:
 - lib/lighthouse/rb_lighthouse.rb
 - lib/lighthouse/reference_resolver.rb
 - lib/lighthouse/relation_batch.rb
+- lib/lighthouse/relation_counts.rb
+- lib/lighthouse/resolve_info.rb
 - lib/lighthouse/resolver_bases.rb
 - lib/lighthouse/resolver_dispatch.rb
+- lib/lighthouse/root_types.rb
+- lib/lighthouse/scalar_coercion.rb
 - lib/lighthouse/schema_cache.rb
 - lib/lighthouse/schema_factory.rb
 - lib/lighthouse/schema_generator.rb
@@ -177,10 +207,16 @@ files:
 - lib/lighthouse/support/authorization.rb
 - lib/lighthouse/support/batching.rb
 - lib/lighthouse/support/directive_args.rb
+- lib/lighthouse/support/environment.rb
 - lib/lighthouse/support/model_resolver.rb
 - lib/lighthouse/support/naming.rb
+- lib/lighthouse/support/preload.rb
 - lib/lighthouse/support/soft_deletes.rb
 - lib/lighthouse/tasks/lighthouse.rake
+- lib/lighthouse/type.rb
+- lib/lighthouse/type_resolution.rb
+- lib/lighthouse/upload.rb
+- lib/lighthouse/upload_store.rb
 - lib/lighthouse/where_conditions/operator_map.rb
 - sig/lighthouse.rbs
 - sig/lighthouse/controller.rbs

data/lib/generators/lighthouse/install/templates/schema.rb.tt

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# Executable schema built by Lighthouse from the SDL in <%= sdl_folder %>/. The
-# Dataloader batches relationship loads (@hasMany, @belongsTo, ...) to avoid N+1.
-# base_types names the base classes: every class a Query, Mutation or Subscription
-# field resolves to must inherit from its kind's, and a Subscription field with no
-# class of its own resolves with the subscription one.
-<%= schema_name %> = Lighthouse::GraphQL::RbLightHouse.get_schema(
-  options: {
-    using: { GraphQL::Dataloader => {} },
-    base_types: {
-      resolver: <%= base_class_constant(:queries) %>,
-      mutation: <%= base_class_constant(:mutations) %>,
-      subscription: <%= base_class_constant(:subscriptions) %>
-      # object: Types::BaseObject, ... # graphql-ruby's base classes of the SDL's types
-    }
-  }
-)
-
-# Refuse expensive queries before they run (see the gem's docs/security.md):
-# <%= schema_name %>.max_complexity(300)
-# <%= schema_name %>.max_depth(12)

data/lib/generators/lighthouse/mutation_generator.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'class_generator'
-
-# `rails generate lighthouse:mutation PublishPost` — the class (a
-# Mutations::BaseMutation, so a GraphQL::Schema::Mutation) that `Mutation.publishPost`
-# resolves to by convention.
-class Lighthouse::Generators::MutationGenerator < Lighthouse::Generators::ClassGenerator
-  desc 'Generate the class of a Mutation field (a Mutations::BaseMutation) in app/graphql/mutations.'
-
-  private
-
-  def kind = :mutations
-
-  def body
-    <<~RUBY
-      # Resolves Mutation.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
-      # arguments in snake_case; `object` and `context` are available. Raise
-      # GraphQL::ExecutionError for failures the client should see.
-      class #{class_basename} < #{superclass_name}
-        def resolve(**args)
-          raise NotImplementedError
-        end
-      end
-    RUBY
-  end
-
-  def usage
-    "Mutation.#{class_basename.camelize(:lower)} resolves to #{full_class_name} — add the field to your SDL without a resolving directive."
-  end
-end

data/lib/generators/lighthouse/query_generator.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'class_generator'
-
-# `rails generate lighthouse:query LatestPosts` — the resolver (a
-# Resolvers::BaseResolver, so a GraphQL::Schema::Resolver) that `Query.latestPosts`
-# resolves to by convention.
-class Lighthouse::Generators::QueryGenerator < Lighthouse::Generators::ClassGenerator
-  desc 'Generate the resolver of a Query field (a Resolvers::BaseResolver) in app/graphql/resolvers.'
-
-  private
-
-  def kind = :queries
-
-  def body
-    <<~RUBY
-      # Resolves Query.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
-      # arguments in snake_case; `object` and `context` are available.
-      class #{class_basename} < #{superclass_name}
-        def resolve(**args)
-          raise NotImplementedError
-        end
-      end
-    RUBY
-  end
-
-  def usage
-    "Query.#{class_basename.camelize(:lower)} resolves to #{full_class_name} — add the field to your SDL without a resolving directive."
-  end
-end