lighthouse-graphql 0.1.1 → 0.2.1

data/lib/lighthouse/directive_resolvers/builder_applier.rb

@@ -2,62 +2,64 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class BuilderApplier
-        def self.apply(relation, field_def_ast_node, args, ctx, resolver_instance)
-          return relation unless field_def_ast_node && field_def_ast_node.directives
-
-          builder_directives = field_def_ast_node.directives.select { |d| d.name == 'builder' }
-          return relation if builder_directives.empty?
-
-          builder_directives.each do |directive_node|
-            relation = apply_directive(relation, directive_node, args, ctx, resolver_instance)
-          end
-
-          relation
-        end
-
-        def self.apply_directive(relation, directive_node, args, ctx, resolver_instance)
-          class_name = extract_directive_arg(directive_node, 'class')
-          method_name = extract_directive_arg(directive_node, 'method') || 'call'
-
-          return relation unless class_name
-
-          builder_class = resolver_instance.send(:constantize_model, class_name)
-          return relation unless builder_class
-
-          if builder_class.respond_to?(method_name)
-            result = builder_class.public_send(method_name, relation, args, ctx)
-            result || relation
-          elsif builder_class.is_a?(Class)
-            instance = builder_class.new
-            if instance.respond_to?(method_name)
-              result = instance.public_send(method_name, relation, args, ctx)
-              result || relation
-            else
-              relation
-            end
-          else
-            relation
-          end
-        rescue ::GraphQL::ExecutionError
-          # Client-facing errors (e.g. authorization / scoping guards raised by a
-          # builder) MUST propagate — never silently fall back to the unscoped
-          # relation, or a builder that enforces tenancy could be bypassed.
-          raise
-        rescue StandardError => e
-          Lighthouse::Config.handle_error(e)
-          relation
-        end
-
-        def self.extract_directive_arg(directive_node, name)
-          arg = directive_node.arguments&.find { |a| a.name == name }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
-      end
+class Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier
+  DEFINITION = 'directive @builder(class: String!, method: String) repeatable on FIELD_DEFINITION'
+
+  def self.apply(relation, field_def_ast_node, args, ctx, resolver_instance)
+    return relation unless field_def_ast_node&.directives
+
+    builder_directives = field_def_ast_node.directives.select { |d| d.name == 'builder' }
+    return relation if builder_directives.empty?
+
+    builder_directives.each do |directive_node|
+      relation = apply_directive(relation, directive_node, args, ctx, resolver_instance)
     end
+
+    relation
+  end
+
+  def self.apply_directive(relation, directive_node, args, ctx, _resolver_instance)
+    class_name = extract_directive_arg(directive_node, 'class')
+    method_name = extract_directive_arg(directive_node, 'method') || 'call'
+
+    return relation unless class_name
+
+    # Builders are not resolvers: they compose onto a relation, and live in
+    # their own namespace (Config.namespaces[:builders], app/graphql/builders).
+    builder_class = Lighthouse::Support::ModelResolver.constantize(
+      class_name, namespaces: Lighthouse::Config.namespaces[:builders]
+    )
+    return relation unless builder_class
+
+    receiver = builder_receiver(builder_class, method_name)
+    return relation unless receiver
+
+    receiver.public_send(method_name, relation, args, ctx) || relation
+  rescue ::GraphQL::ExecutionError
+    # Client-facing errors (e.g. authorization / scoping guards raised by a
+    # builder) MUST propagate — never silently fall back to the unscoped
+    # relation, or a builder that enforces tenancy could be bypassed.
+    raise
+  rescue StandardError => e
+    Lighthouse::Config.handle_error(e)
+    relation
+  end
+
+  def self.extract_directive_arg(directive_node, name)
+    arg = directive_node.arguments&.find { |a| a.name == name }
+    return nil unless arg
+
+    arg.value.respond_to?(:value) ? arg.value.value : arg.value
+  end
+
+  # What answers the builder method: the class itself, else an instance
+  # of it; nil when neither does.
+  def self.builder_receiver(builder_class, method_name)
+    return builder_class if builder_class.respond_to?(method_name)
+    return nil unless builder_class.is_a?(Class)
+
+    instance = builder_class.new
+    instance if instance.respond_to?(method_name)
   end
+  private_class_method :builder_receiver
 end

data/lib/lighthouse/directive_resolvers/cache_resolvers.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse::GraphQL::DirectiveResolvers
+  # @cache — keep a field's resolved value in Config.cache_store (Rails.cache).
+  #
+  # The key covers the parent type and its key (the field marked @cacheKey,
+  # else the first `ID` field; none on Query/Mutation), the field, and its
+  # arguments; `private: true` adds the authenticated user, so each user gets
+  # their own entry (guests share one). `maxAge` is in seconds; without it
+  # entries live until @clearCache or eviction. Lists and relations are
+  # cached as arrays; a value the store cannot serialize (e.g. a connection)
+  # is reported through Config.on_error and returned uncached.
+  class CacheDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    def self.directive_name = 'cache'
+    def self.definition = 'directive @cache(maxAge: Int, private: Boolean = false) on FIELD_DEFINITION'
+
+    ROOT_TYPES = %w[Query Mutation Subscription].freeze
+
+    def define_resolver(target_type_class)
+      type_name = @type_def.graphql_name
+      field_name = @field_def.name
+      max_age = directive_arg('maxAge')
+      per_user = directive_arg('private') == true
+      parent_key = parent_key_reader
+      inner = capture_inner(target_type_class)
+
+      install(target_type_class, lambda do |obj, args, ctx|
+        user_key = per_user ? CacheDirectiveResolver.user_key(ctx) : nil
+        key = Lighthouse::GraphQL::Caching.entry_key(type_name, parent_key&.call(obj), field_name, args, user_key)
+        cached = Lighthouse::GraphQL::Caching.store.read(key)
+        next cached[:value] if cached.is_a?(Hash) && cached.key?(:value)
+
+        value = CacheDirectiveResolver.materialize(inner.call(obj, args, ctx))
+        CacheDirectiveResolver.write(key, value, max_age, ctx)
+        value
+      end)
+    end
+
+    def self.user_key(ctx)
+      user = Lighthouse::Support::Authorization.authenticated_user(ctx)
+      return nil if user.nil?
+
+      "user:#{user.respond_to?(:id) ? user.id : user}"
+    end
+
+    def self.materialize(value)
+      Lighthouse::Support::Arguments.list(value) || value
+    end
+
+    def self.write(key, value, max_age, ctx)
+      Lighthouse::GraphQL::Caching.store.write(key, { value: value }, expires_in: max_age)
+    rescue TypeError, ArgumentError, NoMethodError => e
+      Lighthouse::Config.handle_error(e, ctx)
+    end
+
+    private
+
+    # A callable reading the parent's cache key, or nil on root types.
+    def parent_key_reader
+      return nil if ROOT_TYPES.include?(@type_def.graphql_name)
+
+      key_field = cache_key_field
+      return nil unless key_field
+
+      name = key_field.name
+      ->(obj) { obj.nil? ? nil : Lighthouse::Support::Arguments.read(obj, name) }
+    end
+
+    # The field marked @cacheKey, else the first `ID` field.
+    def cache_key_field
+      fields = @type_def.fields.values
+      fields.find { |f| cache_key?(f) } || fields.find { |f| f.type.unwrap.graphql_name == 'ID' }
+    end
+
+    def cache_key?(field)
+      field.ast_node&.directives&.any? { |d| d.name == 'cacheKey' }
+    end
+  end
+
+  # @clearCache — on a mutation, invalidate @cache entries once the field
+  # resolved successfully. `type` alone clears all of that type's entries;
+  # `idSource` narrows it to the ids found at an argument path
+  # (`{ argument: "input.id" }`) or a result path (`{ field: "*.id" }`), and
+  # `field` to a single field.
+  class ClearCacheDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    def self.directive_name = 'clearCache'
+
+    def self.definition
+      'directive @clearCache(type: String!, idSource: ClearCacheIdSource, field: String) ' \
+        'repeatable on FIELD_DEFINITION'
+    end
+
+    def self.type_definitions
+      {
+        'ClearCacheIdSource' => <<~GRAPHQL.chomp
+          "Where @clearCache finds the ids to clear. Exactly one of the fields must be given."
+          input ClearCacheIdSource {
+            "Path of an argument the field is applied to, e.g. \\"input.id\\"."
+            argument: String
+            "Path of a field in the result, e.g. \\"*.id\\" for a list."
+            field: String
+          }
+        GRAPHQL
+      }
+    end
+
+    def define_resolver(target_type_class)
+      type = directive_arg('type')
+      field = directive_arg('field')
+      source = directive_arg('idSource') || {}
+      inner = capture_inner(target_type_class)
+
+      install(target_type_class, lambda do |obj, args, ctx|
+        result = inner.call(obj, args, ctx)
+        ids =
+          if source['argument']
+            Lighthouse::Support::Arguments.dig(Lighthouse::Support::Arguments.plain(args), source['argument'])
+          elsif source['field']
+            Lighthouse::Support::Arguments.dig(result, source['field'])
+          end
+
+        if ids.nil?
+          Lighthouse::GraphQL::Caching.clear(type, field: field)
+        else
+          ids.flatten.uniq.each { |id| Lighthouse::GraphQL::Caching.clear(type, id: id, field: field) }
+        end
+        result
+      end)
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/can_resolvers.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse::GraphQL::DirectiveResolvers
+  # The @can* family — PHP Lighthouse's authorization directives, checked
+  # with Pundit by default (Config.authorizer): `ability: "update"` calls
+  # `PostPolicy#update?`. Each directive differs only in WHAT it authorizes:
+  #
+  #   @canFind      the models whose primary keys an argument holds
+  #   @canModel     the model class (e.g. create? before a @create)
+  #   @canQuery     the models the field's query would return
+  #   @canResolved  whatever the field resolved to (each item of a list)
+  #   @canRoot      the parent object
+  #
+  # Shared arguments: `injectArgs` passes the field's arguments to the policy
+  # method, `args` passes static values after them, and `action` decides what
+  # a denial (or a @canFind miss) does — pass the error, replace it with a
+  # generic "This action is unauthorized.", or return `returnValue` instead.
+  # All are repeatable; they run after @guard and before validation.
+  class CanDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    COMMON_ARGUMENTS = 'ability: String!, injectArgs: Boolean = false, args: CanArgs, ' \
+                       'action: CanAction = EXCEPTION_PASS, returnValue: CanArgs'
+
+    TYPE_DEFINITIONS = {
+      'CanArgs' => '"Any constant literal value: https://graphql.github.io/graphql-spec/draft/#sec-Input-Values"' \
+                   "\nscalar CanArgs",
+      'CanAction' => <<~GRAPHQL.chomp
+        "What a @can* directive does when the policy denies the ability."
+        enum CanAction {
+          "Pass the error to the client."
+          EXCEPTION_PASS
+          "Throw a generic \\"This action is unauthorized.\\" error, concealing the real one."
+          EXCEPTION_NOT_AUTHORIZED
+          "Return the value of returnValue instead of resolving the field."
+          RETURN_VALUE
+        }
+      GRAPHQL
+    }.freeze
+
+    def self.type_definitions = TYPE_DEFINITIONS
+
+    def self.definition_with(extra = nil)
+      "directive @#{directive_name}(#{[COMMON_ARGUMENTS, extra].compact.join(', ')}) repeatable on FIELD_DEFINITION"
+    end
+
+    def define_resolver(target_type_class)
+      me = self
+      inner = capture_inner(target_type_class)
+      install(target_type_class, lambda do |obj, args, ctx|
+        catch(me) { me.send(:authorize_and_resolve, inner, obj, args, ctx) }
+      end)
+    end
+
+    protected
+
+    def authorize_and_resolve(inner, obj, args, ctx)
+      check { authorize_before(obj, args, ctx) }
+      inner.call(obj, args, ctx)
+    end
+
+    def authorize_before(_obj, _args, _ctx)
+      raise NotImplementedError
+    end
+
+    # Run an authorization step, turning its failure into what `action:` asks for.
+    def check
+      yield
+    rescue ::GraphQL::ExecutionError
+      case directive_arg('action')
+      when 'EXCEPTION_NOT_AUTHORIZED' then raise Lighthouse::AuthorizationError
+      when 'RETURN_VALUE' then throw(self, directive_arg('returnValue'))
+      else raise
+      end
+    end
+
+    def authorize!(ctx, record, args)
+      ability = directive_arg('ability')
+      return if Lighthouse::Support::Authorization.authorized?(ctx, record, ability, policy_args(args))
+
+      raise Lighthouse::AuthorizationError
+    end
+
+    def authorize_each!(ctx, records, args)
+      records.each { |record| authorize!(ctx, record, args) }
+    end
+
+    def policy_args(args)
+      values = []
+      values << Lighthouse::Support::Arguments.plain(args) if directive_arg('injectArgs')
+      static = directive_arg('args')
+      values.concat(static.is_a?(Array) ? static : [static]) unless static.nil?
+      values
+    end
+
+    def scoped(relation)
+      Array(directive_arg('scopes')).reduce(relation) { |acc, scope| acc.public_send(scope) }
+    end
+  end
+
+  class CanFindDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canFind'
+    def self.definition = definition_with('find: String!, model: String, findOrFail: Boolean = true, scopes: [String!]')
+
+    protected
+
+    def authorize_before(_obj, args, ctx)
+      model = model_class
+      ids = Lighthouse::Support::Arguments.dig(Lighthouse::Support::Arguments.plain(args), directive_arg('find')).flatten.uniq
+      records = scoped(model.where(model.primary_key => ids)).to_a
+      if directive_arg('findOrFail') != false && records.size < ids.size
+        missing = ids.map(&:to_s) - records.map { |r| r.public_send(model.primary_key).to_s }
+        raise ::GraphQL::ExecutionError, "Couldn't find #{model.name} with '#{model.primary_key}'=#{missing.join(', ')}"
+      end
+
+      authorize_each!(ctx, records, args)
+    end
+  end
+
+  class CanModelDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canModel'
+    def self.definition = definition_with('model: String')
+
+    protected
+
+    def authorize_before(_obj, args, ctx)
+      authorize!(ctx, model_class, args)
+    end
+  end
+
+  class CanQueryDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canQuery'
+    def self.definition = definition_with('model: String, scopes: [String!]')
+
+    protected
+
+    # The records the field's argument filters (@eq, @where, ...) select.
+    def authorize_before(_obj, args, ctx)
+      authorize_each!(ctx, apply_where_filters(scoped(model_class.all), args).to_a, args)
+    end
+  end
+
+  class CanResolvedDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canResolved'
+    def self.definition = definition_with
+
+    protected
+
+    # The resolver runs first: only use it on fields that do not mutate data.
+    def authorize_and_resolve(inner, obj, args, ctx)
+      result = inner.call(obj, args, ctx)
+      check { authorize_each!(ctx, resolved_records(result), args) }
+      result
+    end
+
+    def resolved_records(result)
+      case result
+      when nil then []
+      when Lighthouse::GraphQL::Pagination::Paginator then result.data
+      when Lighthouse::GraphQL::Pagination::Connection then result.edges.pluck('node')
+      when Hash then result.key?('data') ? Array(result['data']) : [result] # a simple paginator, or a record as a Hash
+      else Lighthouse::Support::Arguments.list(result) || [result]
+      end
+    end
+  end
+
+  class CanRootDirectiveResolver < CanDirectiveResolver
+    def self.directive_name = 'canRoot'
+    def self.definition = definition_with
+
+    protected
+
+    def authorize_before(obj, args, ctx)
+      authorize!(ctx, obj, args)
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/convention_resolver.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+# Resolves a Query or Mutation field that has no resolving directive by
+# convention, as PHP Lighthouse does: `Query.latestPosts` resolves to
+# `Queries::LatestPosts` (a GraphQL::Schema::Resolver), `Mutation.publishPost`
+# to `Mutations::PublishPost` (a GraphQL::Schema::Mutation), looked up in
+# Config.namespaces[:queries] / [:mutations] at call time so code reloading
+# keeps working. Not a directive: SchemaGenerator installs it.
+class Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def initialize(field_def, type_def, kind)
+    super(field_def, type_def, nil)
+    @kind = kind
+  end
+
+  def define_resolver(target_type_class)
+    me = self
+    inner = capture_inner(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      me.send(:resolve_by_convention, inner, obj, args, ctx)
+    end)
+  end
+
+  ROOT_KINDS = { 'Query' => :queries, 'Mutation' => :mutations }.freeze
+
+  # :queries / :mutations for the conventional root type names. The
+  # SchemaGenerator passes the schema's actual roots as `root_kind:`.
+  def self.root_kind_of(type)
+    ROOT_KINDS[type.respond_to?(:graphql_name) ? type.graphql_name : type.to_s]
+  end
+
+  private
+
+  def resolve_by_convention(inner, obj, args, ctx)
+    namespaces = Lighthouse::Config.namespaces[@kind]
+    klass = Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: namespaces, fallback: false)
+    return missing(namespaces, inner, obj, args, ctx) unless klass
+
+    unless Lighthouse::GraphQL::ResolverDispatch.graphql_resolver?(klass)
+      raise Lighthouse::DefinitionError,
+            "#{klass} resolves #{location}, so it must inherit from GraphQL::Schema::Resolver " \
+            '(or GraphQL::Schema::Mutation).'
+    end
+
+    Lighthouse::GraphQL::ResolverDispatch.call(klass, @field_def, obj, args, ctx)
+  end
+
+  # No class: the root object may still answer (a custom root_value);
+  # otherwise report the misconfiguration through Config.on_error.
+  def missing(namespaces, inner, obj, args, ctx)
+    return inner.call(obj, args, ctx) if obj && !obj.is_a?(Hash) && obj.respond_to?(@field_def.name)
+
+    expected = Array(namespaces).map { |ns| "#{ns}::#{class_name}" }.join(' or ')
+    Lighthouse::Config.handle_error(
+      Lighthouse::DefinitionError.new("#{location} has no resolver: define #{expected}, or add a resolving directive."),
+      ctx
+    )
+    nil
+  end
+
+  def class_name
+    @class_name ||= @field_def.name.to_s.camelize
+  end
+
+  def location
+    @location ||= "#{@type_def.graphql_name}.#{@field_def.name}"
+  end
+end

data/lib/lighthouse/directive_resolvers/count_resolver.rb

@@ -3,54 +3,48 @@
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @count(model: "Model", relation: "assoc") — return the number of records.
-      # Counts `Model.all` when `model:` is given, otherwise the named relation on
-      # the parent object (or a relation matching the field name). Honors @builder
-      # and where/argument filters before counting.
-      class CountDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'count'
-        def self.definition = 'directive @count(model: String, relation: String, scopes: [String!]) on FIELD_DEFINITION'
-
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-          model_name = directive_arg('model')
-          relation_name = directive_arg('relation')
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
-
-          resolver = lambda do |obj, arguments, ctx|
-            args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-            relation =
-              if model_name
-                model_class = resolver_instance.constantize_model(model_name)
-                model_class&.all
-              elsif relation_name && obj.respond_to?(relation_name)
-                obj.public_send(relation_name)
-              elsif obj.respond_to?(field_name)
-                obj.public_send(field_name)
-              end
-
-            next 0 unless relation.respond_to?(:count)
-
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
-            relation = resolver_instance.apply_where_filters(relation, args_h)
-            relation.count
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
-
-        private
-
-        def directive_arg(name)
-          Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
-        end
-      end
+# @count(model: "Model", relation: "assoc") — return the number of records.
+# Counts `Model.all` when `model:` is given, otherwise the named relation on
+# the parent object (or a relation matching the field name). Honors `scopes:`, @builder
+# and where/argument filters before counting.
+class Lighthouse::GraphQL::DirectiveResolvers::CountDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'count'
+  def self.definition = 'directive @count(model: String, relation: String, scopes: [String!]) on FIELD_DEFINITION'
+
+  def define_resolver(target_type_class)
+    model_name = directive_arg('model')
+    relation_name = directive_arg('relation')
+    me = self
+
+    install(target_type_class, lambda do |obj, arguments, ctx|
+      me.send(:count_records, me.send(:countable, obj, model_name, relation_name), arguments, ctx)
+    end)
+  end
+
+  private
+
+  def directive_arg(name)
+    Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
+  end
+
+  def countable(obj, model_name, relation_name)
+    field_name = @field_def.name
+    if model_name
+      constantize_model(model_name)&.all
+    elsif relation_name && obj.respond_to?(relation_name)
+      obj.public_send(relation_name)
+    elsif obj.respond_to?(field_name)
+      obj.public_send(field_name)
     end
   end
+
+  def count_records(relation, arguments, ctx)
+    return 0 unless relation.respond_to?(:count)
+
+    args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+    relation = apply_scopes(relation)
+    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, @field_def.ast_node, args_h, ctx, self)
+    relation = apply_where_filters(relation, args_h)
+    relation.count
+  end
 end