lighthouse-graphql 0.3.0 → 0.4.0

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

data/lib/lighthouse/schema_generator.rb

@@ -45,17 +45,21 @@ module Lighthouse::GraphQL::SchemaGenerator
     # and fresh (see SchemaCache), else built now.
     document = build_document(sdl_string)
     impl = default_implementation
+    # base_types' resolver / mutation / subscription are Lighthouse's, not graphql-ruby's.
+    bases = Lighthouse::GraphQL::ResolverBases.extract!(opts)
     schema = from_document(document, impl, opts)
 
     delegate_to_federation_sdl(schema)
     Lighthouse::GraphQL::GeneratedResolvers.install_dispatcher(schema)
     attach_schema(impl, schema)
-    post_process(schema, impl, **opts)
+    post_process(schema, impl, bases: bases, **opts)
     schema.trace_with(Lighthouse::Events::ExecutionTrace)
 
     # @cacheControl hints become the response's Cache-Control header,
     # computed per query from the fields it selects.
     schema.query_analyzer(Lighthouse::GraphQL::CacheControl::Analyzer) if uses_cache_control
+    # The score graphql-ruby checks against max_complexity, for BuildExtensionsResponse.
+    schema.query_analyzer(Lighthouse::GraphQL::Complexity::Analyzer)
 
     schema
   end
@@ -124,7 +128,8 @@ module Lighthouse::GraphQL::SchemaGenerator
     augment_sdl_with_connections(inject_directive_definitions(sdl))
   end
 
-  def post_process(schema, _impl, **_opts)
+  # `bases`: { root kind => the base class its fields' classes inherit from } (ResolverBases).
+  def post_process(schema, _impl, bases: {}, **_opts)
     root_kinds = root_kinds(schema)
 
     # Inspect types and fields for directives and attach generated resolvers
@@ -134,9 +139,12 @@ module Lighthouse::GraphQL::SchemaGenerator
       # Apply object-level federation directives to generated types so the
       # Apollo Federation helper can detect entities and add _entities.
       Lighthouse::GraphQL::FederationDirectives.apply(type)
-      type.fields.each_value { |field_def| process_field(type, field_def, root_kinds[type.graphql_name]) }
+      type.fields.each_value { |field_def| process_field(type, field_def, root_kinds[type.graphql_name], bases) }
     end
 
+    # @complexity, and paginated fields, give graphql-ruby's complexity analysis their cost.
+    Lighthouse::GraphQL::Complexity.apply(schema, root_kinds)
+
     # @feature hides a field or type per query, through graphql-ruby's visibility.
     Lighthouse::GraphQL::FeatureDirective.apply(schema)
 
@@ -155,10 +163,10 @@ module Lighthouse::GraphQL::SchemaGenerator
 
   # A field's generated resolvers, then the runtime hooks that make
   # graphql-ruby reach them.
-  def process_field(type, field_def, root_kind)
+  def process_field(type, field_def, root_kind, bases = {})
     return unless field_def.ast_node
 
-    apply_field_resolvers(type, field_def, field_def.ast_node.directives || [], root_kind)
+    apply_field_resolvers(type, field_def, field_def.ast_node.directives || [], root_kind, bases)
     Lighthouse::GraphQL::GeneratedResolvers.route_runtime_resolver(type, field_def)
     ensure_connection_extension(field_def)
   end
@@ -180,8 +188,8 @@ module Lighthouse::GraphQL::SchemaGenerator
   end
 
   # A field's resolvers, installed in resolution order (see FieldResolverStack).
-  def apply_field_resolvers(type, field_def, directives, root_kind)
-    Lighthouse::GraphQL::FieldResolverStack.apply(type, field_def, directives, root_kind)
+  def apply_field_resolvers(type, field_def, directives, root_kind, bases = {})
+    Lighthouse::GraphQL::FieldResolverStack.apply(type, field_def, directives, root_kind, bases: bases)
   end
 
   # Scan SDL string for list-typed fields that carry relationship directives

data/lib/lighthouse/sdl_loader.rb

@@ -6,8 +6,6 @@ module Lighthouse::GraphQL::SDLLoader
   def load_from_folder(folder)
     files = Dir[File.join(folder, '**', '*.graphql')]
     if files.empty?
-      # fallback to the monolithic schema.graphql in apps/chatwoot
-      # schema.graphql is located at apps/chatwoot/schema.graphql
       default = File.expand_path('../../..//schema.graphql', __dir__)
       return File.read(default) if File.exist?(default)
 

data/lib/lighthouse/support/model_resolver.rb

@@ -25,7 +25,7 @@ module Lighthouse::Support::ModelResolver
 
   # `namespaces:` overrides the configured resolver_namespaces, e.g. with
   # Config.namespaces[:builders] to look a builder class up.
-  # `fallback: false` skips the bare name, so `Queries::User` is never
+  # `fallback: false` skips the bare name, so `Resolvers::User` is never
   # mistaken for the `User` model.
   def constantize(name, namespaces: self.namespaces, fallback: true)
     return nil unless name

data/sig/lighthouse/graphql.rbs

@@ -97,6 +97,35 @@ module Lighthouse
       def self?.apply: (untyped response, untyped result) -> String?
     end
 
+    # What fields cost in graphql-ruby's complexity analysis (@complexity, and
+    # paginated fields scaled by `first`).
+    module Complexity
+      DEFINITION: String
+      CONTEXT_KEY: Symbol
+
+      # Give the schema's fields their cost; `root_kinds` maps root type names to
+      # :queries / :mutations / :subscriptions.
+      def self?.apply: (untyped schema, ?Hash[String, Symbol] root_kinds) -> untyped
+      # A query's score, once scored for BuildExtensionsResponse; nil otherwise.
+      def self?.query_complexity: (untyped query) -> Integer?
+    end
+
+    # A concern for a GraphQL::Analysis::Analyzer that @complexity(resolver:)
+    # names (graphql-ruby ships no RBS, so the class it is included in is not
+    # declared): its `complexity` is the cost of the fields naming the class.
+    module ComplexityAnalyzer
+      # Only when the class has a `result` of its own.
+      def analyze?: () -> bool
+      def result: () -> nil
+
+      # The class methods the concern adds to its includer.
+      module ClassMethods
+        # A number (added to the selection's cost) or a proc of
+        # (context, args, child_complexity); nil when never set.
+        def complexity: (?(Numeric | ^(context, arguments, Integer) -> Integer)? new_complexity) -> (Numeric | ^(context, arguments, Integer) -> Integer)?
+      end
+    end
+
     # The opt-in cache of the manipulated schema document, in tmp/cache.
     module SchemaCache
       PREFIX: String

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lighthouse-graphql
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Vaz Innovation
@@ -68,8 +68,10 @@ files:
 - docs/performance.md
 - docs/relationships.md
 - docs/resolvers.md
+- docs/security.md
 - docs/subscriptions.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/install_generator.rb
@@ -87,6 +89,8 @@ files:
 - lib/lighthouse/broadcasting.rb
 - lib/lighthouse/cache_control.rb
 - lib/lighthouse/caching.rb
+- lib/lighthouse/complexity.rb
+- lib/lighthouse/complexity_analyzer.rb
 - lib/lighthouse/config.rb
 - lib/lighthouse/contracts/arg_builder.rb
 - lib/lighthouse/contracts/arg_manipulator.rb
@@ -161,6 +165,7 @@ files:
 - lib/lighthouse/rb_lighthouse.rb
 - lib/lighthouse/reference_resolver.rb
 - lib/lighthouse/relation_batch.rb
+- lib/lighthouse/resolver_bases.rb
 - lib/lighthouse/resolver_dispatch.rb
 - lib/lighthouse/schema_cache.rb
 - lib/lighthouse/schema_factory.rb