lighthouse-graphql 0.1.1 → 0.2.1

data/lib/lighthouse/directive_resolvers/field_resolver.rb

@@ -2,77 +2,36 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class FieldDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-
-          resolver_class_name = extract_directive_arg('resolver') || extract_directive_arg('class')
-          resolver_instance = self
-
-          resolver = proc do |obj, args, ctx|
-            begin
-              resolver_class = resolver_instance.constantize_model(resolver_class_name)
-              return nil unless resolver_class
-
-              if resolver_class.respond_to?(:call)
-                result = resolver_class.call(obj, args, ctx)
-              else
-                instance = resolver_class.new
-                if instance.respond_to?(:call)
-                  result = instance.call(obj, args, ctx)
-                elsif instance.respond_to?(:resolve)
-                  result = instance.resolve(obj, args, ctx)
-                else
-                  result = nil
-                end
-              end
-
-              result
-            rescue StandardError => e
-              raise e
-            end
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = resolver
-          end
-        end
+class Lighthouse::GraphQL::DirectiveResolvers::FieldDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'field'
+  def self.definition = 'directive @field(resolver: String, class: String) on FIELD_DEFINITION'
+
+  # On Query and Mutation the class is looked up in the queries / mutations
+  # namespaces; on any other type, in Config.resolver_namespaces.
+  def define_resolver(target_type_class)
+    field_def = @field_def
+    class_name = extract_directive_arg('resolver') || extract_directive_arg('class')
+    kind = root_kind(target_type_class)
+
+    install(target_type_class, lambda do |obj, args, ctx|
+      namespaces = kind ? Lighthouse::Config.namespaces[kind] : Lighthouse::Config.resolver_namespaces
+      klass = Lighthouse::Support::ModelResolver.constantize(class_name, namespaces: namespaces)
+      next nil unless klass
+
+      Lighthouse::GraphQL::ResolverDispatch.call(klass, field_def, obj, args, ctx)
+    end)
+  end
 
-        private
+  private
 
-        def extract_directive_arg(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
+  def extract_directive_arg(name)
+    arg = @directive_node.arguments&.find { |a| a.name == name }
+    return nil unless arg
 
-        def execute_resolver(resolver_class, obj, args, ctx)
-          return nil unless resolver_class
+    arg.value.respond_to?(:value) ? arg.value.value : arg.value
+  end
 
-          if resolver_class.respond_to?(:call)
-            resolver_class.call(obj, args, ctx)
-          elsif resolver_class.respond_to?(:new)
-            instance = resolver_class.new
-            if instance.respond_to?(:call)
-              instance.call(obj, args, ctx)
-            elsif instance.respond_to?(:resolve)
-              instance.resolve(obj, args, ctx)
-            else
-              nil
-            end
-          else
-            nil
-          end
-        rescue StandardError => e
-          raise e
-        end
-      end
-    end
+  def root_kind(target_type_class)
+    @opts[:root_kind] || Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver.root_kind_of(target_type_class)
   end
 end

data/lib/lighthouse/directive_resolvers/find_resolver.rb

@@ -2,64 +2,54 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class FindDirectiveResolver < BaseDirectiveResolver
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-
-          model_name_static = extract_model_name || @field_def.type.unwrap.name
-          model_class_static = constantize_model(model_name_static)
-
-          target_type_class.define_singleton_method(method_name) do |_obj, arguments, ctx|
-            args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-            id = args[:id] || args['id']
-
-            model_class = model_class_static
-            return nil unless model_class
+# @find — the single record the field's argument filters select:
+#
+#   user(id: ID! @eq): User @find
+#   userByEmail(email: String! @eq): User @find
+#
+# A lookup by `id` alone is batched through the Dataloader, and an `id`
+# argument without a filter directive selects by primary key. More than one
+# match is an error, as in PHP Lighthouse; none returns null.
+class Lighthouse::GraphQL::DirectiveResolvers::FindDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'find'
+  def self.definition = 'directive @find(model: String, scopes: [String!]) on FIELD_DEFINITION'
+
+  def define_resolver(target_type_class)
+    me = self
+    install(target_type_class, lambda do |_obj, args, ctx|
+      me.send(:find, Lighthouse::Support::Arguments.shallow(args), ctx)
+    end)
+  end
 
-            if id && ctx&.dataloader
-              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::ModelLoader, model_class)
-              return loader.load(id)
-            end
+  protected
 
-            model_class.find_by(id: id)
-          end
+  def find(args, ctx)
+    model = model_class
+    dataloader = Lighthouse::Support::Batching.dataloader(ctx)
+    return dataloader.with(Lighthouse::GraphQL::DataloaderSources::ModelLoader, model).load(args[:id]) if dataloader && batchable?(args)
 
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(_obj, arguments, ctx) do
-              args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-              id = args[:id] || args['id']
+    records = find_relation(model, args).limit(2).to_a
+    raise ::GraphQL::ExecutionError, 'The query returned more than one result.' if records.size > 1
 
-              model_class = model_class_static
-              if model_class.nil?
-                nil
-              elsif id && ctx&.dataloader
-                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::ModelLoader, model_class)
-                loader.load(id)
-              else
-                model_class.find_by(id: id)
-              end
-            end
-          end
-        end
+    records.first
+  end
 
-        private
+  # Only a lookup by `id` alone, with no scopes to apply, can be batched.
+  def batchable?(args)
+    args.keys == [:id] && !directive_arg('scopes')
+  end
 
-        def extract_model_name
-          arg = @directive_node.arguments&.find { |a| a.name == 'model' }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
+  def find_relation(model, args)
+    relation = apply_scopes(model.all)
+    relation = relation.where(model.primary_key => args[:id]) if args.key?(:id) && !filtered?('id')
+    apply_where_filters(relation, args)
+  end
 
-        def constantize_model(name)
-          return nil unless name
-          name = name.to_s.split('::').last
-          Object.const_get(name) rescue nil
-        end
-      end
-    end
+  # Does the argument carry a filter directive (@eq, @where, ...)? An `id`
+  # without one still selects by primary key.
+  def filtered?(name)
+    argument = (@field_def.ast_node&.arguments || []).find { |a| a.name == name }
+    registry = Lighthouse::DirectiveRegistry.default
+    argument&.directives&.any? { |d| registry.arg_builder_class(d.name) }
   end
 end

data/lib/lighthouse/directive_resolvers/first_resolver.rb

@@ -3,51 +3,45 @@
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @first(model: "Model") — return a single record (the first match). Like
-      # @all but `.first`, honoring @builder and where/argument filters so it can
-      # be combined with @eq/@where to fetch one record by criteria.
-      class FirstDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'first'
-        def self.definition = 'directive @first(model: String, scopes: [String!]) on FIELD_DEFINITION'
-
-        def define_resolver(target_type_class)
-          method_name = "resolve_field_#{@field_def.name}"
-          model_name_static = directive_arg('model') || field_type_name
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
-
-          resolver = lambda do |_obj, arguments, ctx|
-            model_class = resolver_instance.constantize_model(model_name_static)
-            next nil unless model_class
-
-            args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-            relation = model_class.all
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
-            relation = resolver_instance.apply_where_filters(relation, args_h)
-            relation.first
-          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
-
-        def field_type_name
-          unwrapped = @field_def.type.respond_to?(:unwrap) ? @field_def.type.unwrap : @field_def.type
-          return unwrapped.graphql_name if unwrapped.respond_to?(:graphql_name) && unwrapped.graphql_name
-          return unwrapped.name if unwrapped.respond_to?(:name) && unwrapped.name
-
-          @field_def.type.to_type_signature.to_s.gsub(/[!\[\]]/, '')
-        end
-      end
+# @first(model: "Model") — return a single record (the first match). Like
+# @all but `.first`, honoring `scopes:`, @builder and where/argument filters so it can
+# be combined with @eq/@where to fetch one record by criteria.
+class Lighthouse::GraphQL::DirectiveResolvers::FirstDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'first'
+  def self.definition = 'directive @first(model: String, scopes: [String!]) on FIELD_DEFINITION'
+
+  def define_resolver(target_type_class)
+    method_name = "resolve_field_#{@field_def.name}"
+    model_name_static = directive_arg('model') || field_type_name
+    resolver_instance = self
+    field_ast_node = @field_def.ast_node
+
+    resolver = lambda do |_obj, arguments, ctx|
+      model_class = resolver_instance.constantize_model(model_name_static)
+      next nil unless model_class
+
+      args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+      relation = resolver_instance.apply_scopes(model_class.all)
+      relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
+      relation = resolver_instance.apply_where_filters(relation, args_h)
+      relation.first
     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
+
+  def field_type_name
+    unwrapped = @field_def.type.respond_to?(:unwrap) ? @field_def.type.unwrap : @field_def.type
+    return unwrapped.graphql_name if unwrapped.respond_to?(:graphql_name) && unwrapped.graphql_name
+    return unwrapped.name if unwrapped.respond_to?(:name) && unwrapped.name
+
+    @field_def.type.to_type_signature.to_s.gsub(/[!\[\]]/, '')
   end
 end

data/lib/lighthouse/directive_resolvers/guard_resolver.rb

@@ -2,31 +2,25 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @guard — require an authenticated user before the field resolves.
-      # Wraps the field's resolver; raises "Unauthenticated." when no user is
-      # present (per Config.authenticated_user). Mirrors PHP Lighthouse's @guard.
-      class GuardDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'guard'
-        def self.definition = 'directive @guard on FIELD_DEFINITION'
+# @guard — require an authenticated user before the field resolves.
+# Wraps the field's resolver; raises "Unauthenticated." when no user is
+# present (per Config.authenticated_user). Mirrors PHP Lighthouse's @guard.
+class Lighthouse::GraphQL::DirectiveResolvers::GuardDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'guard'
+  def self.definition = 'directive @guard on FIELD_DEFINITION'
 
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-          inner = Resolution.capture(target_type_class, method_name, @field_def, field_name)
+  def define_resolver(target_type_class)
+    field_name = @field_def.name
+    method_name = "resolve_field_#{field_name}"
+    inner = Lighthouse::GraphQL::DirectiveResolvers::Resolution.capture(target_type_class, method_name, @field_def, field_name)
 
-          wrapper = lambda do |obj, arguments, ctx|
-            raise(::GraphQL::ExecutionError, 'Unauthenticated.') unless Lighthouse::Support::Authorization.authenticated?(ctx)
+    wrapper = lambda do |obj, arguments, ctx|
+      raise(::GraphQL::ExecutionError, 'Unauthenticated.') unless Lighthouse::Support::Authorization.authenticated?(ctx)
 
-            inner.call(obj, arguments, ctx)
-          end
-
-          target_type_class.define_singleton_method(method_name, &wrapper)
-          @field_def.resolve_proc = wrapper if @field_def.respond_to?(:resolve_proc=)
-        end
-      end
+      inner.call(obj, arguments, ctx)
     end
+
+    target_type_class.define_singleton_method(method_name, &wrapper)
+    @field_def.resolve_proc = wrapper if @field_def.respond_to?(:resolve_proc=)
   end
 end

data/lib/lighthouse/directive_resolvers/method_resolver.rb

@@ -2,34 +2,28 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @method(name: "someMethod") — resolve the field by calling a method on the
-      # parent object. Mirrors PHP Lighthouse's @method. Defaults to the field's
-      # own (snake_cased) name when `name` is omitted.
-      #
-      #   labels: [String!]! @method(name: "label_list")
-      #   canReply: Boolean   @method(name: "can_reply?")
-      class MethodDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'method'
-        def self.definition = 'directive @method(name: String) on FIELD_DEFINITION'
+# @method(name: "someMethod") — resolve the field by calling a method on the
+# parent object. Mirrors PHP Lighthouse's @method. Defaults to the field's
+# own (snake_cased) name when `name` is omitted.
+#
+#   labels: [String!]! @method(name: "label_list")
+#   canReply: Boolean   @method(name: "can_reply?")
+class Lighthouse::GraphQL::DirectiveResolvers::MethodDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'method'
+  def self.definition = 'directive @method(name: String) on FIELD_DEFINITION'
 
-        def define_resolver(target_type_class)
-          resolver_method = "resolve_field_#{@field_def.name}"
-          target_method = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'name') ||
-                           Lighthouse::Support::Naming.attribute(@field_def.name)).to_s
+  def define_resolver(target_type_class)
+    resolver_method = "resolve_field_#{@field_def.name}"
+    target_method = (Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'name') ||
+                     Lighthouse::Support::Naming.attribute(@field_def.name)).to_s
 
-          resolver = lambda do |obj, _arguments, _ctx|
-            next nil if obj.nil?
+    resolver = lambda do |obj, _arguments, _ctx|
+      next nil if obj.nil?
 
-            obj.respond_to?(target_method) ? obj.public_send(target_method) : nil
-          end
-
-          target_type_class.define_singleton_method(resolver_method, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
-      end
+      obj.respond_to?(target_method) ? obj.public_send(target_method) : nil
     end
+
+    target_type_class.define_singleton_method(resolver_method, &resolver)
+    @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
   end
 end

data/lib/lighthouse/directive_resolvers/model_mutation_resolver.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse::GraphQL::DirectiveResolvers
+  # Shared by @create, @createMany, @update, @updateMany, @upsert and
+  # @upsertMany: saves the model a field returns through ActiveRecord, so the
+  # model's own validations decide what is valid — the Rails way — and nested
+  # input on its associations runs as nested mutations (see NestedMutations).
+  # Failures raise a Lighthouse::ValidationError keyed by argument path. The
+  # whole field runs in one transaction (Config.transactional_mutations).
+  #
+  # Arguments map to attributes by their snake_case name, or @rename's
+  # `attribute:`; @spread merges an input object into its parent; @inject
+  # adds server-side values. On an argument, these directives take
+  # `relation:` and act on that association of the parent instead.
+  class ModelMutationResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+    ARGUMENTS = 'model: String, relation: String'
+    LOCATIONS = 'FIELD_DEFINITION | ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
+
+    def define_resolver(target_type_class)
+      me = self
+      install(target_type_class, lambda do |obj, args, ctx|
+        model = me.send(:model_class)
+        me.send(:transaction, model) { me.send(:mutate, model, obj, args, ctx) }
+      end)
+    end
+
+    protected
+
+    def mutate(_model, _obj, _args, _ctx)
+      raise NotImplementedError
+    end
+
+    def executor
+      Lighthouse::GraphQL::NestedMutations::Executor.new(@field_def.name)
+    end
+
+    def transaction(model, &block)
+      Lighthouse::Config.transactional_mutations ? model.transaction(&block) : yield
+    end
+
+    def field_input(args, ctx)
+      values = Lighthouse::Support::Arguments.inject(@field_def.ast_node, Lighthouse::Support::Arguments.shallow(args), ctx)
+      Lighthouse::GraphQL::NestedMutations::Input.new(values, @field_def.arguments, [])
+    end
+
+    NOT_EXACTLY_ONE_ARGUMENT = '@*Many directives must ensure that clients pass exactly one field argument.'
+    ARGUMENT_NOT_LIST = '@*Many directives must ensure that the single argument value is a list.'
+    LIST_ITEM_NOT_INPUT_OBJECT = '@*Many directives must ensure that the list items of its single argument value are input objects.'
+
+    # The inputs of the single list-of-inputs argument of the *Many directives.
+    def item_inputs(args)
+      argument = list_argument
+      items = Array(Lighthouse::Support::Arguments.shallow(args)[argument.keyword])
+      items.each_with_index.map do |item, index|
+        Lighthouse::GraphQL::NestedMutations::Input.new(Lighthouse::Support::Arguments.shallow(item), argument.type.unwrap.arguments,
+                                                        [argument.graphql_name, index.to_s])
+      end
+    end
+
+    # The field's single argument, which must be a list of input objects.
+    def list_argument
+      argument = @field_def.arguments.values.first
+      raise Lighthouse::DefinitionError, NOT_EXACTLY_ONE_ARGUMENT unless @field_def.arguments.size == 1
+      raise Lighthouse::DefinitionError, ARGUMENT_NOT_LIST unless argument.type.list?
+      raise Lighthouse::DefinitionError, LIST_ITEM_NOT_INPUT_OBJECT unless argument.type.unwrap.kind.input_object?
+
+      argument
+    end
+
+    # Save every item, then raise once with all their errors (the
+    # transaction rolls the saved ones back).
+    def each_item(inputs)
+      messages = {}
+      records = inputs.map do |input|
+        yield input
+      rescue Lighthouse::ValidationError => e
+        messages.merge!(e.messages) { |_, a, b| a + b }
+        nil
+      end
+      raise Lighthouse::ValidationError.new(@field_def.name, messages) unless messages.empty?
+
+      records
+    end
+
+    def identifying_columns
+      return nil unless @directive_node.arguments.any? { |a| a.name == 'identifyingColumns' }
+
+      Array(directive_arg('identifyingColumns'))
+    end
+
+    # An empty list would match any record; refuse it when the schema is built.
+    def validate_identifying_columns!
+      return unless identifying_columns && identifying_columns.empty?
+
+      raise Lighthouse::DefinitionError,
+            "@#{@directive_node.name} on #{@type_def.graphql_name}.#{@field_def.name}: identifyingColumns must not be empty."
+    end
+  end
+
+  # @create — create a model from the field's arguments.
+  class CreateDirectiveResolver < ModelMutationResolver
+    def self.directive_name = 'create'
+    def self.definition = "directive @create(#{ARGUMENTS}) on #{LOCATIONS}"
+
+    protected
+
+    def mutate(model, _obj, args, ctx) = executor.create(model, field_input(args, ctx))
+  end
+
+  # @createMany — create one model per input in the field's single list argument.
+  class CreateManyDirectiveResolver < ModelMutationResolver
+    def self.directive_name = 'createMany'
+    def self.definition = "directive @createMany(#{ARGUMENTS}) on #{LOCATIONS}"
+
+    protected
+
+    def mutate(model, _obj, args, _ctx)
+      each_item(item_inputs(args)) { |input| executor.create(model, input) }
+    end
+  end
+
+  # @update — find a model by its primary key argument and update it.
+  class UpdateDirectiveResolver < ModelMutationResolver
+    def self.directive_name = 'update'
+    def self.definition = "directive @update(#{ARGUMENTS}) on #{LOCATIONS}"
+
+    protected
+
+    def mutate(model, _obj, args, ctx) = executor.update(model, field_input(args, ctx))
+  end
+
+  # @updateMany — update one model per input (each carrying its primary key).
+  class UpdateManyDirectiveResolver < ModelMutationResolver
+    def self.directive_name = 'updateMany'
+    def self.definition = "directive @updateMany(#{ARGUMENTS}) on #{LOCATIONS}"
+
+    protected
+
+    def mutate(model, _obj, args, _ctx)
+      each_item(item_inputs(args)) { |input| executor.update(model, input) }
+    end
+  end
+
+  # @upsert — update the model the arguments identify (by `identifyingColumns`,
+  # else primary key), or create it.
+  class UpsertDirectiveResolver < ModelMutationResolver
+    def self.directive_name = 'upsert'
+    def self.definition = "directive @upsert(#{ARGUMENTS}, identifyingColumns: [String!]) on #{LOCATIONS}"
+
+    def define_resolver(target_type_class)
+      validate_identifying_columns!
+      super
+    end
+
+    protected
+
+    def mutate(model, _obj, args, ctx)
+      # rubocop:disable-next Rails/SkipsModelValidations -- Executor#upsert, not ActiveRecord's: it saves through validations.
+      executor.upsert(model, field_input(args, ctx), identifying: identifying_columns)
+    end
+  end
+
+  # @upsertMany — @upsert for each input in the field's single list argument.
+  class UpsertManyDirectiveResolver < ModelMutationResolver
+    def self.directive_name = 'upsertMany'
+    def self.definition = "directive @upsertMany(#{ARGUMENTS}, identifyingColumns: [String!]) on #{LOCATIONS}"
+
+    def define_resolver(target_type_class)
+      validate_identifying_columns!
+      super
+    end
+
+    protected
+
+    def mutate(model, _obj, args, _ctx)
+      columns = identifying_columns
+      # rubocop:disable-next Rails/SkipsModelValidations -- Executor#upsert, not ActiveRecord's: it saves through validations.
+      each_item(item_inputs(args)) { |input| executor.upsert(model, input, identifying: columns) }
+    end
+  end
+
+  # @delete — destroy the models the field's argument filters select
+  # (@whereKey, @eq, ...), running their callbacks, and return them: a list
+  # for a list field, else the first or null. Refuses to run without a
+  # filter argument, which would delete every row.
+  class DeleteDirectiveResolver < ModelMutationResolver
+    def self.directive_name = 'delete'
+    def self.definition = "directive @delete(#{ARGUMENTS}, scopes: [String!]) on #{LOCATIONS}"
+
+    WOULD_MODIFY_ALL = 'Would modify all models, use an argument to filter.'
+
+    protected
+
+    # A record whose callbacks refuse the destroy is reported as an error next
+    # to the data, as PHP Lighthouse does; the others are still deleted.
+    def mutate(model, _obj, args, ctx)
+      args = Lighthouse::Support::Arguments.shallow(args)
+      raise ::GraphQL::ExecutionError, WOULD_MODIFY_ALL unless filtered?(args)
+
+      relation = Array(directive_arg('scopes')).reduce(model.all) { |acc, scope| acc.public_send(scope) }
+      records = apply_where_filters(relation, args).to_a
+      records.each do |record|
+        next if record.destroy
+
+        ctx.add_error(::GraphQL::ExecutionError.new("Could not modify model #{model.name} with ID #{record.id}."))
+      end
+      @field_def.type.list? ? records : records.first
+    end
+
+    def filtered?(args)
+      registry = Lighthouse::DirectiveRegistry.default
+      (@field_def.ast_node.arguments || []).any? do |argument|
+        args.key?(argument.name.underscore.to_sym) && argument.directives.any? { |d| registry.arg_builder_class(d.name) }
+      end
+    end
+  end
+end