lighthouse-graphql 0.1.1 → 0.2.1

data/lib/lighthouse/config.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'active_support/cache'
+
 module Lighthouse
   # Convenience entrypoint: `Lighthouse.configure { |c| c.resolver_namespaces = [...] }`.
   def self.configure(&block)
@@ -7,12 +9,30 @@ module Lighthouse
   end
 
   module Config
+    # Where each kind of class a schema refers to by name is looked up. Query and
+    # mutation fields resolve to GraphQL::Schema::Resolver / Mutation classes,
+    # builders compose onto a relation, validators check arguments: distinct
+    # contracts, so distinct namespaces (app/graphql/queries, .../mutations, ...).
+    DEFAULT_NAMESPACES = {
+      queries: ['Queries'],
+      mutations: ['Mutations'],
+      builders: ['Builders'],
+      validators: ['Validators']
+    }.freeze
+
+    # Every setting reset! forgets, so the next read falls back to its default.
+    SETTINGS = %i[
+      sdl_folder resolver_namespaces namespaces cache_store transactional_mutations pagination_default_count pagination_max_count
+      schema_cache schema_cache_path watch_sdl persisted_queries persisted_queries_store persisted_queries_ttl
+      persisted_queries_manifest persisted_queries_only on_error directive_map authenticated_user policy_user authorizer
+    ].freeze
+
     class << self
-      attr_writer :sdl_folder, :resolver_namespaces, :on_error,
-                  :authenticated_user, :policy_user, :authorizer
+      attr_writer :sdl_folder, :resolver_namespaces, :on_error, :authenticated_user, :policy_user, :authorizer, :cache_store,
+                  :transactional_mutations, :schema_cache, :watch_sdl, :persisted_queries, :persisted_queries_store, :persisted_queries_only
 
       def sdl_folder
-        @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? File.join(Rails.root, 'graphql') : nil)
+        @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.join('graphql').to_s : nil)
       end
 
       def directive_map
@@ -27,6 +47,57 @@ module Lighthouse
         @resolver_namespaces ||= ['App::Graphql']
       end
 
+      # { queries:, mutations:, builders:, validators: } => [namespace, ...].
+      # Assigning a partial hash overrides only the kinds it names.
+      def namespaces
+        @namespaces ||= DEFAULT_NAMESPACES.transform_values(&:dup)
+      end
+
+      def namespaces=(overrides)
+        @namespaces = namespaces.merge(overrides.to_h.transform_keys(&:to_sym).transform_values { |v| Array(v) })
+      end
+
+      # Store backing @cache and @clearCache. Defaults to Rails.cache.
+      def cache_store
+        @cache_store ||=
+          if defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
+            Rails.cache
+          else
+            ActiveSupport::Cache::MemoryStore.new
+          end
+      end
+
+      # --- Scale options: all off by default ----------------------------------
+      #
+      # schema_cache          cache the built schema document in tmp/cache (SchemaCache)
+      # schema_cache_path     where; default Rails.root/tmp/cache/lighthouse
+      # watch_sdl             reload the app (and so the schema) when a .graphql file changes
+      # persisted_queries     accept Apollo's Automatic Persisted Queries (PersistedQueries)
+      # persisted_queries_store     where APQ keeps queries; default cache_store
+      # persisted_queries_ttl       how long they live there (seconds; nil: until evicted)
+      # persisted_queries_manifest  a manifest of trusted operations, served by hash
+      # persisted_queries_only      reject any operation not in the manifest
+      attr_accessor :schema_cache_path, :persisted_queries_ttl, :persisted_queries_manifest
+
+      def schema_cache = @schema_cache || false
+      def watch_sdl = @watch_sdl || false
+      def persisted_queries = @persisted_queries || false
+      def persisted_queries_only = @persisted_queries_only || false
+
+      def persisted_queries_store
+        @persisted_queries_store || cache_store
+      end
+
+      # Pagination defaults, overridden by a directive's defaultCount / maxCount.
+      # Without a default count, paginated fields require `first`.
+      attr_accessor :pagination_default_count, :pagination_max_count
+
+      # Run @create/@update/... in a database transaction, so a failing record
+      # (e.g. the third of five in @createMany) leaves nothing behind.
+      def transactional_mutations
+        @transactional_mutations.nil? || @transactional_mutations
+      end
+
       # Hook invoked when a directive/resolver swallows an error. Defaults to
       # re-raising in test (so failures surface) and logging otherwise. Override
       # via `Lighthouse.configure { |c| c.on_error = ->(e, ctx) { ... } }`.
@@ -56,8 +127,10 @@ module Lighthouse
         end
       end
 
-      # Checks an ability: `->(user, record, ability) { true/false }`.
-      # Defaults to Pundit: `Pundit.policy!(user, record).<ability>?`.
+      # Checks an ability: `->(user, record, ability, args = []) { true/false }`.
+      # `record` may be a model class (@canModel). `args` carries the @can*
+      # `args:` values and, with `injectArgs: true`, the field's arguments first.
+      # Defaults to Pundit: `Pundit.policy!(user, record).<ability>?(*args)`.
       def authorizer
         @authorizer ||= default_authorizer
       end
@@ -66,29 +139,22 @@ module Lighthouse
         yield(self) if block_given?
       end
 
-      def [](k)
-        public_send(k)
+      def [](key)
+        public_send(key)
       end
 
       def reset!
-        @sdl_folder = nil
-        @resolver_namespaces = nil
-        @on_error = nil
-        @directive_map = nil
-        @authenticated_user = nil
-        @policy_user = nil
-        @authorizer = nil
+        SETTINGS.each { |setting| instance_variable_set("@#{setting}", nil) }
       end
 
       private
 
       def default_authorizer
-        lambda do |user, record, ability|
-          unless defined?(::Pundit)
-            raise 'Lighthouse: configure `Config.authorizer` to use @can (Pundit not detected).'
-          end
+        lambda do |user, record, ability, args = []|
+          raise 'Lighthouse: configure `Config.authorizer` to use the @can* directives (Pundit not detected).' unless defined?(::Pundit)
 
-          ::Pundit.policy!(user, record).public_send("#{ability}?")
+          check = ::Pundit.policy!(user, record).method("#{ability}?")
+          check.arity.zero? ? check.call : check.call(*args)
         end
       end
 

data/lib/lighthouse/contracts/arg_builder.rb

@@ -2,16 +2,12 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive on a field ARGUMENT that composes a constraint onto an
-    # ActiveRecord relation at resolve time, e.g. @eq, @neq, @in, @notIn, @like,
-    # @where, @orderBy. These compose in SDL argument order via the
-    # ArgBuilderPipeline.
-    #
-    # Implementors provide `#handle_builder(relation, value)` returning a relation.
-    module ArgBuilder
-      include Directive
-    end
-  end
+# A directive on a field ARGUMENT that composes a constraint onto an
+# ActiveRecord relation at resolve time, e.g. @eq, @neq, @in, @notIn, @like,
+# @where, @orderBy. These compose in SDL argument order via the
+# ArgBuilderPipeline.
+#
+# Implementors provide `#handle_builder(relation, value)` returning a relation.
+module Lighthouse::Contracts::ArgBuilder
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/arg_manipulator.rb

@@ -2,16 +2,12 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive on a field ARGUMENT that mutates the schema AST before build,
-    # e.g. @whereConditions / @whereHasConditions generating input/enum types and
-    # swapping the `_` placeholder argument type.
-    #
-    # Implementors provide (at the class level)
-    # `manipulate_argument_definition(manipulation_context, parent, field, arg, directive)`.
-    module ArgManipulator
-      include Directive
-    end
-  end
+# A directive on a field ARGUMENT that mutates the schema AST before build,
+# e.g. @whereConditions / @whereHasConditions generating input/enum types and
+# swapping the `_` placeholder argument type.
+#
+# Implementors provide (at the class level)
+# `manipulate_argument_definition(manipulation_context, parent, field, arg, directive)`.
+module Lighthouse::Contracts::ArgManipulator
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/directive.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  # Contracts are duck-typed marker modules that mirror the PHP Lighthouse
-  # directive interfaces. A directive class includes whichever contracts it
-  # fulfils; the DirectiveRegistry and SchemaGenerator detect capabilities via
-  # `klass.include?(Contracts::X)` and invoke the corresponding hook.
-  module Contracts
-    # Base marker. Every Lighthouse directive class includes this.
-    #
-    # Implementors are expected to expose (at the class level):
-    #   - `directive_name` -> String   the SDL name without the leading '@'
-    #   - `definition`     -> String?  the SDL `directive @name(...) on ...` line
-    module Directive
-    end
-  end
+# Contracts are duck-typed marker modules that mirror the PHP Lighthouse
+# directive interfaces. A directive class includes whichever contracts it
+# fulfils; the DirectiveRegistry and SchemaGenerator detect capabilities via
+# `klass.include?(Contracts::X)` and invoke the corresponding hook.
+# Base marker. Every Lighthouse directive class includes this.
+#
+# Implementors are expected to expose (at the class level):
+#   - `directive_name` -> String   the SDL name without the leading '@'
+#   - `definition`     -> String?  the SDL `directive @name(...) on ...` line
+module Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/field_manipulator.rb

@@ -2,16 +2,12 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive that mutates the schema AST before it is built, e.g. @paginate
-    # and the relationship directives injecting Connection/Paginator types, or
-    # @orderBy generating its column enum.
-    #
-    # Implementors provide (at the class level)
-    # `manipulate_field_definition(manipulation_context, parent, field, directive)`.
-    module FieldManipulator
-      include Directive
-    end
-  end
+# A directive that mutates the schema AST before it is built, e.g. @paginate
+# and the relationship directives injecting Connection/Paginator types, or
+# @orderBy generating its column enum.
+#
+# Implementors provide (at the class level)
+# `manipulate_field_definition(manipulation_context, parent, field, directive)`.
+module Lighthouse::Contracts::FieldManipulator
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/field_middleware.rb

@@ -2,15 +2,11 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive that wraps an existing field resolver, e.g. @auth wrapping the
-    # underlying resolver to enforce authentication.
-    #
-    # Implementors provide `#wrap_resolver(next_resolver)` returning a new
-    # `#call(obj, args, ctx)` lambda that may invoke `next_resolver`.
-    module FieldMiddleware
-      include Directive
-    end
-  end
+# A directive that wraps an existing field resolver, e.g. @auth wrapping the
+# underlying resolver to enforce authentication.
+#
+# Implementors provide `#wrap_resolver(next_resolver)` returning a new
+# `#call(obj, args, ctx)` lambda that may invoke `next_resolver`.
+module Lighthouse::Contracts::FieldMiddleware
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/field_resolver.rb

@@ -2,17 +2,13 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive that provides the runtime resolver for a field, e.g. @all,
-    # @find, @paginate, @hasMany, @belongsTo, @field, @auth, @aggregate.
-    #
-    # During the resolution phase the SchemaGenerator instantiates the directive
-    # and installs its resolver onto the field. Legacy resolvers fulfil this via
-    # `#define_resolver(target_type)`; clean directives implement `#resolve_field`
-    # returning a `#call(obj, args, ctx)` lambda.
-    module FieldResolver
-      include Directive
-    end
-  end
+# A directive that provides the runtime resolver for a field, e.g. @all,
+# @find, @paginate, @hasMany, @belongsTo, @field, @auth, @aggregate.
+#
+# During the resolution phase the SchemaGenerator instantiates the directive
+# and installs its resolver onto the field. Legacy resolvers fulfil this via
+# `#define_resolver(target_type)`; clean directives implement `#resolve_field`
+# returning a `#call(obj, args, ctx)` lambda.
+module Lighthouse::Contracts::FieldResolver
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/dataloader_sources/association_loader.rb

@@ -1,25 +1,34 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DataloaderSources
-      class AssociationLoader < ::GraphQL::Dataloader::Source
-        def initialize(model_class, association_name)
-          @model_class = model_class
-          @association_name = association_name.to_s
-        end
+# Loads one association for many parents in a single query per batch, with
+# ActiveRecord's preloader — the N+1 fix behind @hasMany, @belongsTo, ...
+class Lighthouse::GraphQL::DataloaderSources::AssociationLoader < GraphQL::Dataloader::Source
+  def initialize(model_class, association_name)
+    super()
+    @model_class = model_class
+    @association_name = association_name.to_s
+  end
+
+  # keys: the parent records
+  def fetch(parents)
+    preload(parents.select { |parent| association?(parent) })
+    parents.map { |parent| parent.respond_to?(@association_name) ? parent.public_send(@association_name) : nil }
+  end
+
+  private
+
+  def association?(parent)
+    parent.class.respond_to?(:reflect_on_association) && parent.class.reflect_on_association(@association_name)
+  end
+
+  def preload(records)
+    return if records.empty?
 
-        # keys: array of parent objects
-        def fetch(keys)
-          keys.map do |parent|
-            if parent.respond_to?(@association_name)
-              parent.public_send(@association_name)
-            else
-              nil
-            end
-          end
-        end
-      end
+    preloader = ::ActiveRecord::Associations::Preloader
+    if preloader.method_defined?(:call)
+      preloader.new(records: records, associations: @association_name.to_sym).call # Rails >= 7
+    else
+      preloader.new.preload(records, @association_name.to_sym)                       # Rails 6
     end
   end
 end

data/lib/lighthouse/dataloader_sources/model_loader.rb

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DataloaderSources
-      class ModelLoader < ::GraphQL::Dataloader::Source
-        def initialize(model_class)
-          @model_class = model_class
-        end
+class Lighthouse::GraphQL::DataloaderSources::ModelLoader < GraphQL::Dataloader::Source
+  def initialize(model_class)
+    super()
+    @model_class = model_class
+  end
 
-        # keys are ids
-        def fetch(keys)
-          records = @model_class.where(id: keys).index_by(&:id)
-          keys.map { |k| records[k] }
-        end
-      end
-    end
+  # Keys are ids. GraphQL `ID` arguments arrive as strings while records
+  # carry their column type (usually Integer), so match on the string form.
+  def fetch(keys)
+    records = @model_class.where(id: keys).index_by { |record| record.id.to_s }
+    keys.map { |k| records[k.to_s] }
   end
 end

data/lib/lighthouse/dataloader_sources/relation_count_loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# The total of a paginated relation for every parent the Dataloader collected,
+# in one GROUP BY query. Only asked for when the client selects a total.
+class Lighthouse::GraphQL::DataloaderSources::RelationCountLoader < GraphQL::Dataloader::Source
+  def initialize(batch)
+    super()
+    @batch = batch
+  end
+
+  # keys: the parent records
+  def fetch(owners)
+    counts = @batch.counts(owners)
+    owners.map { |owner| counts.fetch(@batch.owner_key(owner), 0) }
+  end
+end

data/lib/lighthouse/dataloader_sources/relation_page_loader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# One page of a paginated relation for every parent the Dataloader collected,
+# in one query (see Lighthouse::GraphQL::RelationBatch).
+class Lighthouse::GraphQL::DataloaderSources::RelationPageLoader < GraphQL::Dataloader::Source
+  def initialize(batch, offset, limit)
+    super()
+    @batch = batch
+    @offset = offset
+    @limit = limit
+  end
+
+  # keys: the parent records
+  def fetch(owners)
+    pages = @batch.pages(owners, @offset, @limit)
+    owners.map { |owner| pages.fetch(@batch.owner_key(owner), []) }
+  end
+end

data/lib/lighthouse/directive_resolvers/aggregate_resolver.rb

@@ -3,84 +3,72 @@
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class AggregateDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
+class Lighthouse::GraphQL::DirectiveResolvers::AggregateDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'aggregate'
 
-          model_name = extract_directive_arg('model')
-          relation_name = extract_directive_arg('relation')
-          column_name = extract_directive_arg('column')
-          function_name = extract_directive_arg('function')
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
+  # An unknown function aggregates to null.
+  AGGREGATIONS = {
+    'SUM' => ->(relation, column) { relation.sum(column) },
+    'AVG' => ->(relation, column) { relation.average(column)&.to_f },
+    'MIN' => ->(relation, column) { relation.minimum(column) },
+    'MAX' => ->(relation, column) { relation.maximum(column) },
+    'COUNT' => ->(relation, _column) { relation.count }
+  }.freeze
 
-          resolver_lambda = lambda do |obj, args, ctx|
-            relation = if model_name
-              model_class = resolver_instance.send(:constantize_model, model_name)
-              model_class ? model_class.all : nil
-            elsif relation_name && obj.respond_to?(relation_name)
-              obj.public_send(relation_name)
-            else
-              nil
-            end
+  def self.definition
+    'directive @aggregate(function: String!, column: String, model: String, relation: String) on FIELD_DEFINITION'
+  end
 
-            return nil unless relation
+  def define_resolver(target_type_class)
+    model_name = extract_directive_arg('model')
+    relation_name = extract_directive_arg('relation')
+    column_name = extract_directive_arg('column')
+    function_name = extract_directive_arg('function')
+    resolver_instance = self
+    field_ast_node = @field_def.ast_node
 
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args, ctx, resolver_instance)
-            resolver_instance.send(:compute_aggregation, relation, column_name, function_name)
-          end
+    install(target_type_class, lambda do |obj, args, ctx|
+      relation = resolver_instance.send(:aggregate_source, obj, model_name, relation_name)
+      return nil unless relation
 
-          target_type_class.define_singleton_method(method_name, &resolver_lambda)
-          @field_def.resolve_proc = resolver_lambda if @field_def.respond_to?(:resolve_proc=)
-        end
+      relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args, ctx, resolver_instance)
+      resolver_instance.send(:compute_aggregation, relation, column_name, function_name)
+    end)
+  end
 
-        private
+  private
 
-        def extract_directive_arg(name)
-          arg = @directive_node.arguments&.find { |a| a.name == name }
-          return nil unless arg
-          v = arg.value.respond_to?(:value) ? arg.value.value : arg.value
-          v.is_a?(::GraphQL::Language::Nodes::Enum) ? v.name : v
-        end
+  def extract_directive_arg(name)
+    arg = @directive_node.arguments&.find { |a| a.name == name }
+    return nil unless arg
 
-        def compute_aggregation(relation, column, function_name)
-          return nil unless relation.respond_to?(:any?)
-          column = column.to_s
-          case function_name.to_s.upcase
-          when 'SUM'
-            relation.sum(column)
-          when 'AVG'
-            relation.average(column)&.to_f
-          when 'MIN'
-            relation.minimum(column)
-          when 'MAX'
-            relation.maximum(column)
-          when 'COUNT'
-            relation.count
-          else
-            nil
-          end
-        rescue StandardError
-          nil
-        end
+    v = arg.value.respond_to?(:value) ? arg.value.value : arg.value
+    v.is_a?(::GraphQL::Language::Nodes::Enum) ? v.name : v
+  end
 
-        def set_resolve_proc(method_name)
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(obj, arguments, ctx) do
-              target_type_class = self.class
-              if target_type_class.respond_to?(method_name)
-                target_type_class.public_send(method_name, obj, arguments, ctx)
-              else
-                nil
-              end
-            end
-          end
-        end
-      end
+  # The model's table when `model:` is given, else the parent's relation.
+  def aggregate_source(obj, model_name, relation_name)
+    if model_name
+      constantize_model(model_name)&.all
+    elsif relation_name && obj.respond_to?(relation_name)
+      obj.public_send(relation_name)
     end
   end
+
+  def compute_aggregation(relation, column, function_name)
+    return nil unless relation.respond_to?(:any?)
+
+    AGGREGATIONS[function_name.to_s.upcase]&.call(relation, column.to_s)
+  rescue StandardError
+    nil
+  end
+
+  def install_resolve_proc(method_name)
+    return unless @field_def.respond_to?(:resolve_proc=)
+
+    @field_def.resolve_proc = lambda { |obj, arguments, ctx|
+      target_type_class = self.class
+      target_type_class.public_send(method_name, obj, arguments, ctx) if target_type_class.respond_to?(method_name)
+    }
+  end
 end