lighthouse-graphql 0.3.0 → 0.5.0

data/lib/lighthouse/global_id.rb

@@ -0,0 +1,31 @@
+# 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.
+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 Config.global_id; a
+  # GraphQL::ExecutionError when it is not one.
+  def decode!(global_id)
+    type, id = 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
+end

data/lib/lighthouse/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module Lighthouse
   module GraphQL
-    VERSION = '0.3.0'
+    VERSION = '0.5.0'
   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

data/lib/lighthouse/rb_lighthouse.rb

@@ -29,6 +29,8 @@ require_relative 'namespaces'
   support/arguments
   support/batching
   support/soft_deletes
+  support/preload
+  support/environment
   where_conditions/operator_map
   contracts/directive
   contracts/field_resolver
@@ -38,12 +40,14 @@ require_relative 'namespaces'
   contracts/arg_builder
   sdl_loader
   generated_resolvers
+  default_resolve_dispatcher
   federation_directives
   field_resolver_stack
   events
   events/lifecycle
   events/execution_trace
   events/schema_build
+  resolver_bases
   schema_generator
   schema_cache
   persisted_queries
@@ -55,14 +59,30 @@ require_relative 'namespaces'
   caching
   cache_control
   feature_directive
+  complexity
+  complexity_analyzer
   broadcasting
   subscription
+  type
+  type_resolution
+  resolve_info
+  global_id
+  enum_directive
+  upload
+  upload_store
+  multipart_request
+  node_registry
+  scalar_coercion
   pagination
   relation_batch
+  relation_counts
   nested_mutations
   directives/pagination_manipulator
   directives/where_conditions_directive
   directives/soft_deletes_directive
+  directives/node_directive
+  directives/model_directive
+  directives/visibility_directive
   directive_resolvers/aggregate_resolver
   directive_resolvers/field_resolver
   directive_resolvers/where_conditions_applier
@@ -80,6 +100,7 @@ require_relative 'namespaces'
   directive_resolvers/association_resolvers
   directive_resolvers/can_resolvers
   directive_resolvers/convention_resolver
+  directive_resolvers/type_method_resolver
   directive_resolvers/model_mutation_resolver
   directive_resolvers/soft_delete_resolvers
   directive_resolvers/cache_resolvers
@@ -88,15 +109,29 @@ require_relative 'namespaces'
   directive_resolvers/broadcast_resolver
   directive_resolvers/event_resolver
   directive_resolvers/convert_empty_strings_resolver
+  directive_resolvers/with_resolver
+  directive_resolvers/with_count_resolver
+  directive_resolvers/lazy_load_resolver
+  directive_resolvers/limit_resolver
+  directive_resolvers/namespaced_resolver
+  directive_resolvers/throttle_resolver
+  directive_resolvers/async_resolver
+  directive_resolvers/global_id_resolver
+  directive_resolvers/argument_binding
+  directive_resolvers/argument_transforms_resolver
   directives/arguments/base
   directives/arguments/filters
+  directives/arguments/more_filters
   directives/arguments/order_by
   directives/arguments/soft_deletes
+  directives/definitions
   directives/registry
   dataloader_sources/association_loader
   dataloader_sources/model_loader
   dataloader_sources/relation_page_loader
   dataloader_sources/relation_count_loader
+  dataloader_sources/relation_counts_loader
+  dataloader_sources/preload_loader
   ide_helper
 ].each do |rel|
   require_relative rel
@@ -106,6 +141,7 @@ end
 
 # The activejob gem is optional: the job that queues @broadcast loads on first use.
 Lighthouse::GraphQL.autoload(:BroadcastJob, File.expand_path('broadcast_job.rb', __dir__))
+Lighthouse::GraphQL.autoload(:AsyncMutationJob, File.expand_path('async_mutation_job.rb', __dir__))
 
 require_relative 'railtie' if defined?(Rails::Railtie)
 

data/lib/lighthouse/relation_counts.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# The counts @withCount loads, read off the record as Laravel's withCount
+# attributes are: `user.posts_count`. The record is extended with this module
+# (named, so it still marshals for @cache) and keeps them in an instance
+# variable; a real column of the same name wins.
+module Lighthouse::GraphQL::RelationCounts
+  def self.write(record, relation, count)
+    record.extend(self) unless record.is_a?(self)
+    counts = record.instance_variable_get(:@lighthouse_relation_counts) || {}
+    record.instance_variable_set(:@lighthouse_relation_counts, counts.merge("#{relation}_count" => count))
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    lighthouse_relation_count?(name) || super
+  end
+
+  def method_missing(name, *args, &block)
+    return super unless args.empty? && lighthouse_relation_count?(name)
+
+    @lighthouse_relation_counts[name.to_s]
+  end
+
+  private
+
+  def lighthouse_relation_count?(name)
+    @lighthouse_relation_counts&.key?(name.to_s)
+  end
+end

data/lib/lighthouse/resolve_info.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# What PHP Lighthouse hands a resolver as its fourth argument, `$resolveInfo`:
+# the field being resolved, where, with what, what the client selects below it
+# (`lookahead`), and `enhance_builder`, which applies the field's own query
+# directives to a query the resolver builds.
+#
+#   type Query {
+#     posts(title: String @eq, orderBy: [PostOrderByClause!] @orderBy): [Post!]! @builder(class: "Published")
+#   }
+#
+#   class Resolvers::Posts < Resolvers::BaseResolver
+#     def resolve(**)
+#       resolve_info.enhance_builder(Post.where(author: context[:current_user]), scopes: [:recent])
+#     end
+#   end
+#
+# A Resolvers:: / Mutations:: class, a class @field names and a type class's
+# methods read it as `resolve_info`; a plain callable gets it as a fourth
+# argument when it takes one: `call(object, args, context, resolve_info)`.
+class Lighthouse::GraphQL::ResolveInfo
+  LOOKAHEAD = :lighthouse_lookahead
+
+  attr_reader :field, :parent_type, :object, :arguments, :context
+
+  # graphql-ruby's GraphQL::Execution::Lookahead for the field: what the client
+  # selects below it, to load only that (`lookahead.selects?(:author)`,
+  # `lookahead.selection(:comments).arguments`). nil outside a query.
+  attr_reader :lookahead
+
+  # A field resolved by a class asks graphql-ruby for its lookahead.
+  def self.request_lookahead(field_def)
+    field_def.extras([:lookahead]) unless field_def.extras.include?(:lookahead)
+  end
+
+  def initialize(field:, parent_type:, object:, arguments:, context:)
+    @field = field
+    @parent_type = parent_type
+    @object = object
+    @arguments = arguments
+    @context = context
+    @lookahead = context.respond_to?(:[]) ? context[LOOKAHEAD] : nil
+  end
+
+  def field_name = field.graphql_name
+
+  def return_type = field.type
+
+  # The path from the root to this field, as graphql-ruby tracks it: ["posts", 0, "author"].
+  def path
+    context.respond_to?(:[]) ? context[:current_path] : nil
+  end
+
+  # `relation` with the field's model `scopes`, its @builder classes, and the
+  # argument directives the client used (@eq, @where, @in, @like, @orderBy,
+  # @whereConditions, @trashed, ...), as @all / @paginate apply them.
+  def enhance_builder(relation, scopes: [])
+    resolver = Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver.new(field, parent_type, nil)
+    args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+    relation = Array(scopes).reduce(relation) { |acc, scope| acc.public_send(scope) }
+    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field.ast_node, args, context, resolver)
+    resolver.apply_where_filters(relation, args, context)
+  end
+
+  # `resolve_info`, for the classes that resolve a field.
+  module Accessor
+    def resolve_info = @lighthouse_resolve_info
+  end
+
+  # Hand `info` to `resolver` (a GraphQL::Schema::Resolver or type class instance).
+  def self.for(field_def, parent_type, object, arguments, context)
+    new(field: field_def, parent_type: parent_type, object: object, arguments: arguments, context: context)
+  end
+
+  def self.attach(resolver, info)
+    resolver.extend(Accessor) unless resolver.respond_to?(:resolve_info)
+    resolver.instance_variable_set(:@lighthouse_resolve_info, info)
+    resolver
+  end
+end

data/lib/lighthouse/resolver_bases.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# The base classes of the classes root fields resolve to, given to `get_schema`
+# beside graphql-ruby's own base types:
+#
+#   Lighthouse::GraphQL::RbLightHouse.get_schema(options: { base_types: {
+#     resolver: Resolvers::BaseResolver, mutation: Mutations::BaseMutation,
+#     subscription: Subscriptions::BaseSubscription, object: Types::BaseObject
+#   } })
+#
+# graphql-ruby's `from_definition` knows only the SDL's own kinds (object,
+# interface, union, scalar, enum, input_object), so these three are taken out
+# before it sees the rest. Each one given:
+#
+# - is the class every class of its kind must inherit from: a Query, Mutation or
+#   Subscription field's class, found by convention or through
+#   @subscription(class:), that does not raises Lighthouse::DefinitionError when
+#   it is first used, so none misses what the base shares;
+# - for subscriptions, also resolves a Subscription field that has no class of
+#   its own, instead of Lighthouse::GraphQL::Subscription::Default.
+module Lighthouse::GraphQL::ResolverBases
+  # base_types key => the graphql-ruby class the base must inherit from.
+  GRAPHQL_CLASSES = {
+    resolver: ::GraphQL::Schema::Resolver,
+    mutation: ::GraphQL::Schema::Mutation,
+    subscription: ::GraphQL::Schema::Subscription
+  }.freeze
+
+  # Root kind => base_types key.
+  KEYS = { queries: :resolver, mutations: :mutation, subscriptions: :subscription }.freeze
+
+  module_function
+
+  # graphql-ruby's base types that the type classes of the same kind
+  # (Types::PostType, Types::DateTimeType, ...) inherit from too.
+  TYPE_KINDS = %i[object union interface scalar].freeze
+
+  # Take the three keys out of opts[:base_types] (the caller's Hash is not
+  # changed) and return { root kind => base class } for those given, plus
+  # :types => { kind => base } for graphql-ruby's own, which stay in opts.
+  def extract!(opts)
+    base_types = opts[:base_types]
+    return {} unless base_types.is_a?(Hash)
+
+    given = base_types.slice(*GRAPHQL_CLASSES.keys).compact
+    opts[:base_types] = base_types.except(*GRAPHQL_CLASSES.keys)
+    given.each { |key, klass| validate!(key, klass) }
+    bases = KEYS.filter_map { |kind, key| [kind, given[key]] if given[key] }.to_h
+    type_bases = base_types.slice(*TYPE_KINDS).compact
+    type_bases.empty? ? bases : bases.merge(types: type_bases)
+  end
+
+  def validate!(key, klass)
+    expected = GRAPHQL_CLASSES.fetch(key)
+    return if klass.is_a?(Class) && klass < expected
+
+    raise Lighthouse::DefinitionError, "base_types[:#{key}] must be a subclass of #{expected}, not #{klass.inspect}."
+  end
+
+  # Raise unless `klass`, which resolves the field at `location`, inherits from
+  # `base` (nil: no base was given).
+  def check!(klass, base, location)
+    return if base.nil? || klass <= base
+
+    raise Lighthouse::DefinitionError,
+          "#{klass} resolves #{location}, so it must inherit from #{base}, the schema's base class for it (base_types)."
+  end
+end

data/lib/lighthouse/resolver_dispatch.rb

@@ -4,7 +4,12 @@
 # namespaces follow graphql-ruby's contract — GraphQL::Schema::Resolver and
 # GraphQL::Schema::Mutation: `resolve(**args)` with `object` and `context`,
 # plus `ready?` / `authorized?` — exactly as in a graphql-ruby schema.
-# @field also accepts a plain callable, `call(object, args, context)`.
+# @field also accepts a plain callable, `call(object, args, context)`, which
+# gets the ResolveInfo as a fourth argument when it takes one.
+#
+# `method:` is the method after `@` in `@field(resolver: "Class@method")`: it
+# replaces `resolve` (keeping `ready?` / `authorized?`) on a resolver class, and
+# `call` on a plain class, as a class method or else an instance method.
 module Lighthouse::GraphQL::ResolverDispatch
   module_function
 
@@ -12,15 +17,35 @@ module Lighthouse::GraphQL::ResolverDispatch
     klass.is_a?(Class) && klass < ::GraphQL::Schema::Resolver
   end
 
-  def call(klass, field_def, obj, args, ctx)
-    if graphql_resolver?(klass)
-      kwargs = Lighthouse::Support::Arguments.prepare(field_def, args, ctx)
-      klass.new(object: obj, context: ctx, field: field_def).resolve_with_support(**kwargs)
-    elsif klass.respond_to?(:call)
-      klass.call(obj, args, ctx)
-    else
-      instance = klass.new
-      instance.respond_to?(:call) ? instance.call(obj, args, ctx) : instance.resolve(obj, args, ctx)
-    end
+  # `info`: the ResolveInfo of the field being resolved, which carries its
+  # object, arguments and context.
+  def call(klass, info, method: nil)
+    return call_resolver(klass, info, method) if graphql_resolver?(klass)
+
+    receiver = callable_receiver(klass, method || :call)
+    callable = receiver.method(method || (receiver.respond_to?(:call) ? :call : :resolve))
+    args = [info.object, info.arguments, info.context]
+    takes_info?(receiver, callable) ? callable.call(*args, info) : callable.call(*args)
+  end
+
+  def call_resolver(klass, info, method)
+    kwargs = Lighthouse::Support::Arguments.prepare(info.field, info.arguments, info.context)
+    instance = Lighthouse::GraphQL::ResolveInfo.attach(klass.new(object: info.object, context: info.context, field: info.field), info)
+    instance.define_singleton_method(:resolve) { |**values| public_send(method, **values) } if method
+    instance.resolve_with_support(**kwargs)
+  end
+
+  # The class itself when it answers `name` as a class method, else an instance.
+  def callable_receiver(klass, name)
+    klass.respond_to?(name) ? klass : klass.new
+  end
+
+  POSITIONAL = %i[req opt].freeze
+
+  # Does the callable take a fourth argument? A lambda's own parameters count,
+  # not Proc#call's (*args).
+  def takes_info?(receiver, callable)
+    params = receiver.is_a?(Proc) && callable.name == :call ? receiver.parameters : callable.parameters
+    params.any? { |type, _| type == :rest } || params.count { |type, _| POSITIONAL.include?(type) } >= 4
   end
 end

data/lib/lighthouse/scalar_coercion.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# How the values of an SDL scalar (`scalar DateTime`) are read from a query and
+# written to a response, as a graphql-ruby scalar class does it with
+# `coerce_input(value, context)` and `coerce_result(value, context)`. The class
+# is, in order:
+#
+# 1. the one `@scalar(class: "Name")` on the scalar names, looked up in
+#    Config.namespaces[:types] (nested names too) and then as written. PHP
+#    Lighthouse's directive.
+# 2. Its type class, Types::<Name>Type including Lighthouse::GraphQL::Type: a
+#    GraphQL::Schema::Scalar, as graphql-ruby's `rails g graphql:scalar` writes it.
+# 3. Lighthouse's own, for `scalar Upload` (Lighthouse::GraphQL::Upload).
+#
+# A scalar with none passes its values through unchanged. A class raising
+# GraphQL::CoercionError from coerce_input (or returning nil for a value) makes
+# the argument invalid, with that message, as in graphql-ruby.
+module Lighthouse::GraphQL::ScalarCoercion
+  DEFINITION = <<~GRAPHQL.chomp
+    """
+    The class that reads and writes this scalar's values: coerce_input(value, context) and
+    coerce_result(value, context), as a GraphQL::Schema::Scalar.
+    """
+    directive @scalar(class: String!) on SCALAR
+  GRAPHQL
+
+  module_function
+
+  # Give every SDL scalar that has a class its coercion. The class is looked up
+  # again on each value, so code reloading keeps working; `bases` is the
+  # schema's base_types[:scalar], which a type class must inherit from.
+  def apply(schema, base = nil)
+    schema.types.each_value do |type|
+      next unless type.kind.scalar? && type.ast_node
+
+      klass = class_for(type, base)
+      install(type, klass) if klass
+    end
+  end
+
+  # Scalars Lighthouse brings a class for, when nothing else names one.
+  BUILT_IN = { 'Upload' => 'Lighthouse::GraphQL::Upload' }.freeze
+
+  def class_for(scalar_type, base = nil)
+    directive_class(scalar_type) || type_class(scalar_type, base) || BUILT_IN[scalar_type.graphql_name]&.constantize
+  end
+
+  def directive_class(scalar_type)
+    directive = (scalar_type.ast_node.directives || []).find { |d| d.name == 'scalar' }
+    name = directive && Lighthouse::Support::DirectiveArgs.literal(directive, 'class')
+    return unless name
+
+    klass = Lighthouse::Support::ModelResolver.constantize(name, namespaces: Lighthouse::Config.namespaces[:types], nested: true)
+    return klass if klass.respond_to?(:coerce_input) && klass.respond_to?(:coerce_result)
+
+    raise Lighthouse::DefinitionError,
+          "@scalar(class: #{name.inspect}) on #{scalar_type.graphql_name} names no class with coerce_input(value, context) " \
+          'and coerce_result(value, context).'
+  end
+
+  def type_class(scalar_type, base)
+    klass = Lighthouse::GraphQL::Type.class_for(scalar_type.graphql_name, :scalar)
+    Lighthouse::GraphQL::ResolverBases.check!(klass, base, "the #{scalar_type.graphql_name} scalar") if klass
+    klass
+  end
+
+  def install(scalar_type, klass)
+    current = -> { klass.name ? klass.name.constantize : klass }
+    scalar_type.define_singleton_method(:coerce_input) { |value, ctx| current.call.coerce_input(value, ctx) }
+    scalar_type.define_singleton_method(:coerce_result) { |value, ctx| current.call.coerce_result(value, ctx) }
+  end
+end

data/lib/lighthouse/schema_cache.rb

@@ -72,7 +72,8 @@ module Lighthouse::GraphQL::SchemaCache
       registry.directive_definitions.sort,
       registry.type_definitions.sort,
       manipulators,
-      Lighthouse::Config.pagination_default_count
+      Lighthouse::Config.pagination_default_count,
+      Lighthouse::Support::Environment.current # @hide / @show
     ].inspect
   end
 

data/lib/lighthouse/schema_factory.rb

@@ -30,7 +30,6 @@ module Lighthouse::GraphQL::SchemaFactory
     folder = sdl_folder || (Lighthouse::GraphQL::Config.sdl_folder if defined?(Lighthouse::GraphQL::Config))
     return Lighthouse::GraphQL::SDLLoader.load_from_folder(folder) if folder && Dir.exist?(folder)
 
-    # fallback to apps/chatwoot/schema.graphql
     File.read(File.expand_path('../../schema.graphql', __dir__))
   end
 end