lighthouse-graphql 0.1.1 → 0.2.0

data/lib/lighthouse/rb_lighthouse.rb

@@ -1,23 +1,33 @@
 # frozen_string_literal: true
 
 # ActiveSupport core extensions the library relies on (underscore, pluralize,
-# blank?/present?, deep_symbolize_keys). In a Rails host these are already
+# blank?/present?, deep_symbolize_keys, index_by/pluck/exclude?). In a Rails host these are already
 # loaded; requiring them here keeps the gem usable standalone.
 require 'active_support'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/string/exclude'
+require 'set'
+require 'graphql'
+
+require_relative 'namespaces'
 
 ## Load internal dependencies individually so a single missing file
 ## doesn't prevent the rest from loading. Failures are logged but not
 ## raised so callers can require specific files if needed.
 %w[
   config
+  errors
+  graphql_ruby_patches
   reference_resolver
   support/naming
   support/directive_args
   support/model_resolver
   support/authorization
+  support/arguments
+  support/batching
   where_conditions/operator_map
   contracts/directive
   contracts/field_resolver
@@ -26,22 +36,29 @@ require 'active_support/core_ext/hash/keys'
   contracts/arg_manipulator
   contracts/arg_builder
   sdl_loader
+  generated_resolvers
+  federation_directives
+  field_resolver_stack
   schema_generator
+  schema_cache
+  persisted_queries
   schema_factory
   schema_implementation
-  directives/relation_directive
+  resolver_dispatch
+  caching
+  cache_control
+  pagination
+  relation_batch
+  nested_mutations
+  directives/pagination_manipulator
   directives/where_conditions_directive
-  directive_resolvers/has_many_resolver
   directive_resolvers/aggregate_resolver
   directive_resolvers/field_resolver
   directive_resolvers/where_conditions_applier
-  directive_resolvers/belongs_to_resolver
   directive_resolvers/all_resolver
   directive_resolvers/find_resolver
   directive_resolvers/paginate_resolver
   directive_resolvers/auth_resolver
-  directive_resolvers/belongs_to_many_resolver
-  directive_resolvers/has_one_resolver
   directive_resolvers/first_resolver
   directive_resolvers/count_resolver
   directive_resolvers/rename_resolver
@@ -49,40 +66,44 @@ require 'active_support/core_ext/hash/keys'
   directive_resolvers/base
   directive_resolvers/resolution
   directive_resolvers/guard_resolver
-  directive_resolvers/can_resolver
+  directive_resolvers/association_resolvers
+  directive_resolvers/can_resolvers
+  directive_resolvers/convention_resolver
+  directive_resolvers/model_mutation_resolver
+  directive_resolvers/cache_resolvers
+  directive_resolvers/validator_resolver
   directives/arguments/base
   directives/arguments/filters
   directives/arguments/order_by
   directives/registry
   dataloader_sources/association_loader
   dataloader_sources/model_loader
+  dataloader_sources/relation_page_loader
+  dataloader_sources/relation_count_loader
+  ide_helper
 ].each do |rel|
-  begin
-    require_relative rel
-  rescue LoadError => e
-    warn("Lighthouse: could not require #{rel}: #{e.message}")
-  end
+  require_relative rel
+rescue LoadError => e
+  warn("Lighthouse: could not require #{rel}: #{e.message}")
 end
 
-module Lighthouse
-  module GraphQL
-    module RbLightHouse
-      class << self
-        def get_schema(sdl_folder: nil, options: {})
-          base_types = options.delete(:base_types) || {}
-          schema_class = options.delete(:base_schema)
+require_relative 'railtie' if defined?(Rails::Railtie)
 
-          Lighthouse::GraphQL::SchemaFactory.build_base_schema(
-            sdl_folder: sdl_folder,
-            base_types: base_types,
-            schema_options: options.merge(schema_class: schema_class)
-          )
-        end
+module Lighthouse::GraphQL::RbLightHouse
+  class << self
+    def get_schema(sdl_folder: nil, options: {})
+      base_types = options.delete(:base_types) || {}
+      schema_class = options.delete(:base_schema)
+
+      Lighthouse::GraphQL::SchemaFactory.build_base_schema(
+        sdl_folder: sdl_folder,
+        base_types: base_types,
+        schema_options: options.merge(schema_class: schema_class)
+      )
+    end
 
-        def configure(&block)
-          Lighthouse::GraphQL::Config.configure(&block) if defined?(Lighthouse::GraphQL::Config)
-        end
-      end
+    def configure(&block)
+      Lighthouse::GraphQL::Config.configure(&block) if defined?(Lighthouse::GraphQL::Config)
     end
   end
 end

data/lib/lighthouse/reference_resolver.rb

@@ -1,24 +1,22 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  class ReferenceResolver
-    @resolvers = {}
+class Lighthouse::ReferenceResolver
+  @resolvers = {}
 
-    class << self
-      def register(typename, &block)
-        @resolvers[typename.to_s] = block
-      end
+  class << self
+    def register(typename, &block)
+      @resolvers[typename.to_s] = block
+    end
 
-      def resolve(typename, reference, context)
-        resolver = @resolvers[typename.to_s]
-        return nil unless resolver
+    def resolve(typename, reference, context)
+      resolver = @resolvers[typename.to_s]
+      return nil unless resolver
 
-        resolver.call(reference, context)
-      end
+      resolver.call(reference, context)
+    end
 
-      def clear!
-        @resolvers.clear
-      end
+    def clear!
+      @resolvers.clear
     end
   end
 end

data/lib/lighthouse/relation_batch.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# The pages of one paginated relation for many parents at once — what PHP
+# Lighthouse's PaginatedModelsLoader does with a UNION ALL per parent and
+# `loadCount`. Here a window function numbers each parent's rows, so the pages
+# of every parent come from one query, and one GROUP BY counts them all:
+#
+#   SELECT * FROM (
+#     SELECT comments.*, ROW_NUMBER() OVER (PARTITION BY comments.author_id ORDER BY ...) AS lighthouse_row,
+#            comments.author_id AS lighthouse_owner
+#     FROM comments WHERE comments.author_id IN (1, 2, 3) AND <the field's scopes and filters>
+#   ) comments WHERE lighthouse_row > 0 AND lighthouse_row <= 10
+#
+#   SELECT COUNT(*), comments.author_id FROM comments WHERE ... GROUP BY comments.author_id
+#
+# A parent's association scope links it through one column on the table
+# nearest to it (comments.author_id; taggings.post_id for a :through), which
+# ActiveRecord's reflection names. The batch swaps that link for an IN over
+# every parent and partitions by the same column. The field's scopes and
+# filters (`decorator.decorate_relation`) apply on top, as for one parent.
+#
+# A batch is equal to another for the same field, parent class and arguments,
+# so the Dataloader collects every parent of a level into one.
+class Lighthouse::GraphQL::RelationBatch
+  ROW = 'lighthouse_row'
+  OWNER = 'lighthouse_owner'
+
+  attr_reader :association_name
+
+  # The batch `owner`'s page belongs to, or nil when this relation cannot be
+  # batched (the database has no window functions, a composite key, a scope
+  # that reads the owner, DISTINCT, ...): each parent then loads its own page.
+  def self.for(owner, association_name, args, decorator, context)
+    return nil unless owner.respond_to?(:association) && owner.class.respond_to?(:reflect_on_association)
+    return nil unless owner.class.reflect_on_association(association_name.to_sym)&.collection?
+
+    batch = new(owner.class, association_name.to_s, args, decorator, context)
+    batch if batch.batchable?(owner)
+  end
+
+  def self.window_functions?(connection)
+    version = connection.database_version
+    case connection.adapter_name
+    when /postg/i then true
+    when /sqlite/i then version >= '3.25'
+    when /mysql|trilogy/i then version >= (connection.respond_to?(:mariadb?) && connection.mariadb? ? '10.2' : '8.0')
+    else false
+    end
+  rescue StandardError
+    false
+  end
+
+  def initialize(owner_class, association_name, args, decorator, context)
+    @owner_class = owner_class
+    @association_name = association_name
+    @args = args
+    @decorator = decorator
+    @context = context
+  end
+
+  def batchable?(owner)
+    linked_by_one_column?(owner) && self.class.window_functions?(owner.class.connection) &&
+      owner_independent?(owner) && rankable?(relation([owner]))
+  end
+
+  # { owner key => its records in rows offset+1..offset+limit }
+  def pages(owners, offset, limit)
+    relation = relation(owners)
+    ranked = relation.unscope(:order).select(*selection(relation), "#{row_number(relation)} AS #{ROW}", "#{partition} AS #{OWNER}")
+    rows = relation.klass.unscoped.from(ranked, relation.klass.table_name)
+                   .where("#{ROW} > ? AND #{ROW} <= ?", offset, offset + limit)
+                   .order(Arel.sql("#{OWNER}, #{ROW}"))
+    preloads = relation.preload_values + relation.includes_values
+    rows = rows.preload(*preloads) if preloads.any?
+    rows.to_a.group_by { |record| record[OWNER].to_s }
+  end
+
+  # { owner key => number of related records }
+  def counts(owners)
+    relation(owners).unscope(:order, :select).group(Arel.sql(partition)).count.transform_keys(&:to_s)
+  end
+
+  def owner_key(owner)
+    owner[@owner_column].to_s
+  end
+
+  def eql?(other)
+    other.is_a?(self.class) && identity == other.identity
+  end
+  alias == eql?
+
+  def hash
+    identity.hash
+  end
+
+  protected
+
+  def identity
+    @identity ||= [@owner_class, @association_name, @decorator, Lighthouse::Support::Arguments.plain(@args)]
+  end
+
+  private
+
+  # The column on the table nearest the owner that holds the owner's key —
+  # where ActiveRecord's AssociationScope puts the owner's condition.
+  def linked_by_one_column?(owner)
+    link = owner.association(@association_name.to_sym).reflection.chain.last
+    return false unless link.respond_to?(:join_primary_key)
+
+    @link_table = link.klass.table_name
+    @link_column = link.join_primary_key
+    @owner_column = link.join_foreign_key
+    [@link_column, @owner_column].none?(Array)
+  end
+
+  # The owner's condition can be swapped for an IN, and no scope reads the owner.
+  def owner_independent?(owner)
+    association = owner.association(@association_name.to_sym)
+    association.reflection.chain.none? { |reflection| reflection.scope&.arity&.positive? } &&
+      unlinked(association.scope).where_clause != association.scope.where_clause
+  end
+
+  # Rows can be numbered in a stable order, and DISTINCT does not fold them.
+  def rankable?(relation)
+    !relation.distinct_value && (relation.arel.orders.any? || relation.klass.primary_key.is_a?(String))
+  end
+
+  def relation(owners)
+    scope = unlinked(owners.first.association(@association_name.to_sym).scope)
+    keys = owners.pluck(@owner_column).uniq
+    @decorator.decorate_relation(scope.where(@link_table => { @link_column => keys }), @args, @context)
+  end
+
+  def unlinked(scope)
+    scope.unscope(where: { @link_table => @link_column })
+  end
+
+  def partition
+    connection = @owner_class.connection
+    "#{connection.quote_table_name(@link_table)}.#{connection.quote_column_name(@link_column)}"
+  end
+
+  # Numbers each parent's rows in the order the field asks for, else by primary key.
+  def row_number(relation)
+    orders = relation.arel.orders.map { |node| node.respond_to?(:to_sql) ? node.to_sql : node.to_s }
+    if orders.empty?
+      connection = relation.klass.connection
+      orders = ["#{connection.quote_table_name(relation.klass.table_name)}.#{connection.quote_column_name(relation.klass.primary_key)}"]
+    end
+    "ROW_NUMBER() OVER (PARTITION BY #{partition} ORDER BY #{orders.join(', ')})"
+  end
+
+  def selection(relation)
+    relation.select_values.presence || [relation.klass.arel_table[Arel.star]]
+  end
+end

data/lib/lighthouse/resolver_dispatch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Calls the class a field resolves to. Classes in the queries and mutations
+# 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)`.
+module Lighthouse::GraphQL::ResolverDispatch
+  module_function
+
+  def graphql_resolver?(klass)
+    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
+  end
+end

data/lib/lighthouse/schema_cache.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'tmpdir'
+
+# Opt-in cache of the schema document Lighthouse builds from your SDL —
+# PHP Lighthouse's schema cache, done the Bootsnap way: a content-addressed
+# file in tmp/cache, no deploy step to remember and nothing to clear by hand.
+#
+# Building a schema parses the SDL, injects directive definitions and runs
+# the manipulators (pagination types, whereConditions inputs, ...), parses
+# the result and builds the executable schema. The cache stores the parsed,
+# manipulated document, so a boot skips everything up to that last step —
+# roughly 60% of the build time.
+#
+# The key covers everything that shapes that document: the SDL, the
+# Lighthouse / graphql-ruby / Ruby versions, the registered directive and
+# type definitions, the source of the manipulators, and the configuration
+# they read. Change any of them and the next boot rebuilds — a stale schema
+# cannot be served. Enable with `Lighthouse.configure { |c| c.schema_cache = true }`;
+# `bin/rails lighthouse:cache` warms it at deploy (e.g. in a Docker build).
+module Lighthouse::GraphQL::SchemaCache
+  PREFIX = 'schema-'
+
+  module_function
+
+  def enabled?
+    Lighthouse::Config.schema_cache
+  end
+
+  def directory
+    Lighthouse::Config.schema_cache_path ||
+      if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
+        ::Rails.root.join('tmp/cache/lighthouse').to_s
+      else
+        File.join(Dir.tmpdir, 'lighthouse-graphql')
+      end
+  end
+
+  # The parsed document for `sdl` after manipulation. `build` turns the SDL
+  # into the manipulated SDL string; it only runs on a cache miss.
+  # `force:` caches even when the cache is off (warm!).
+  def document(sdl, force: false, &build)
+    return parse(yield(sdl)) unless force || enabled?
+
+    path = File.join(directory.to_s, "#{PREFIX}#{key(sdl)}.bin")
+    cached = read(path)
+    return cached if cached
+
+    parse(yield(sdl)).tap { |document| write(path, document) }
+  end
+
+  def key(sdl)
+    Digest::SHA256.hexdigest(
+      [Lighthouse::GraphQL::VERSION, ::GraphQL::VERSION, RUBY_VERSION, sdl.to_s, fingerprint].join("\0")
+    )
+  end
+
+  # Everything besides the SDL that changes the manipulated document.
+  def fingerprint
+    registry = Lighthouse::DirectiveRegistry.default
+    manipulators = registry.sdl_manipulators.map { |manipulator| [manipulator.to_s, source_digest(manipulator)] }
+    [
+      registry.directive_definitions.sort,
+      registry.type_definitions.sort,
+      manipulators,
+      Lighthouse::Config.pagination_default_count
+    ].inspect
+  end
+
+  # Build the schema document now (from Config.sdl_folder, unless given)
+  # and return the cache file's path.
+  def warm!(sdl = nil)
+    sdl ||= Lighthouse::GraphQL::SDLLoader.load_from_folder(Lighthouse::Config.sdl_folder.to_s)
+    document(sdl, force: true) { |source| Lighthouse::GraphQL::SchemaGenerator.manipulate(source) }
+    File.join(directory.to_s, "#{PREFIX}#{key(sdl)}.bin")
+  end
+
+  def clear!
+    Dir[File.join(directory.to_s, "#{PREFIX}*.bin")].each { |file| File.delete(file) }
+  end
+
+  # graphql-ruby's parser for schema definitions, as from_definition uses.
+  def parse(sdl)
+    parser = ::GraphQL.default_parser
+    parser = parser::SchemaParser if parser.const_defined?(:SchemaParser, false)
+    parser.parse(sdl)
+  end
+
+  # A missing, truncated or incompatible file is a miss, never an error.
+  def read(path)
+    return nil unless File.exist?(path)
+
+    # Our own tmp/cache file, as Bootsnap reads its own; never anything a client sent.
+    document = Marshal.load(File.binread(path)) # rubocop:disable Security/MarshalLoad
+    document if document.is_a?(::GraphQL::Language::Nodes::Document)
+  rescue StandardError
+    nil
+  end
+
+  # Write atomically (a concurrent boot never reads half a file), then drop
+  # the entries of earlier keys.
+  def write(path, document)
+    FileUtils.mkdir_p(File.dirname(path))
+    temporary = "#{path}.#{Process.pid}.tmp"
+    File.binwrite(temporary, Marshal.dump(document))
+    File.rename(temporary, path)
+    Dir[File.join(File.dirname(path), "#{PREFIX}*.bin")].each { |file| File.delete(file) unless file == path }
+  rescue SystemCallError => e
+    Lighthouse::Config.handle_error(e)
+  end
+
+  def source_digest(manipulator)
+    file, = manipulator.method(:manipulate).source_location
+    file && File.exist?(file) ? Digest::SHA256.file(file).hexdigest : nil
+  rescue NameError
+    nil
+  end
+end

data/lib/lighthouse/schema_factory.rb

@@ -1,46 +1,36 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    # Public entrypoint for building an executable schema from SDL.
-    #
-    # The returned value is a GraphQL-Ruby schema class (from `GraphQL::Schema.from_definition`)
-    # intended to be subclassed by the application schema class.
-    module SchemaFactory
-      module_function
+# Public entrypoint for building an executable schema from SDL.
+#
+# The returned value is a GraphQL-Ruby schema class (from `GraphQL::Schema.from_definition`)
+# intended to be subclassed by the application schema class.
+module Lighthouse::GraphQL::SchemaFactory
+  module_function
 
-      def build_base_schema(sdl_folder: nil, sdl: nil, base_types: {}, schema_options: {}, **extra_options)
-        # Absorb any extra keyword options (e.g. `federation: true`) into the
-        # schema options bag so callers can pass schema-level flags directly
-        # without the factory needing to enumerate every one.
-        schema_options = extra_options.merge(schema_options)
+  def build_base_schema(sdl_folder: nil, sdl: nil, base_types: {}, schema_options: {}, **extra_options)
+    # Absorb any extra keyword options (e.g. `federation: true`) into the
+    # schema options bag so callers can pass schema-level flags directly
+    # without the factory needing to enumerate every one.
+    schema_options = extra_options.merge(schema_options)
 
-        sdl_string =
-          if sdl
-            sdl
-          else
-            folder = sdl_folder || (Lighthouse::GraphQL::Config.sdl_folder if defined?(Lighthouse::GraphQL::Config))
-            if folder && Dir.exist?(folder)
-              Lighthouse::GraphQL::SDLLoader.load_from_folder(folder)
-            else
-              # fallback to apps/chatwoot/schema.graphql
-              path = File.expand_path('../../schema.graphql', __dir__)
-              File.read(path)
-            end
-          end
+    sdl_string = sdl || load_sdl(sdl_folder)
+    schema_class = schema_options.delete(:schema_class)
 
-        schema_class = schema_options.delete(:schema_class)
+    Lighthouse::GraphQL::SchemaGenerator.build(
+      sdl_string,
+      base_types: base_types,
+      schema_class: schema_class,
+      **schema_options
+    )
+  end
 
-        schema = Lighthouse::GraphQL::SchemaGenerator.build(
-          sdl_string,
-          base_types: base_types,
-          schema_class: schema_class,
-          **schema_options
-        )
+  # The SDL in `sdl_folder` (default: Config.sdl_folder), or the bundled
+  # schema.graphql when there is no such folder.
+  def load_sdl(sdl_folder)
+    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)
 
-        schema
-      end
-    end
+    # fallback to apps/chatwoot/schema.graphql
+    File.read(File.expand_path('../../schema.graphql', __dir__))
   end
 end
-