lighthouse-graphql 0.1.0 → 0.2.0

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

data/lib/lighthouse/directive_resolvers/paginate_resolver.rb

@@ -1,147 +1,89 @@
 # frozen_string_literal: true
 
-require 'ostruct'
 require_relative 'base'
 require_relative 'builder_applier'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      class PaginateDirectiveResolver < BaseDirectiveResolver
-        class PaginatorResult
-          attr_reader :paginator_info, :data
-
-          def initialize(paginator_info:, data:)
-            @paginator_info = paginator_info
-            @data = data
-          end
-
-          def paginatorInfo
-            @paginator_info
-          end
-        end
-
-        def define_resolver(target_type_class)
-          field_name = @field_def.name
-          method_name = "resolve_field_#{field_name}"
-
-          # Resolve model name now, but constantize lazily at call time so
-          # Rails autoloading (Zeitwerk) can load the model after startup.
-          model_name_static = extract_model_name || extract_model_name_from_field_type
-          # If the field was transformed to a Paginator type (e.g. InboxPaginator),
-          # derive the underlying model name by stripping a trailing "Paginator".
-          model_name_static = model_name_static.to_s.sub(/Paginator\z/, '')
-          # Closure to lookup the model class lazily
-          model_lookup = proc { constantize_model(model_name_static) }
-
-
-
-          # Determine whether this paginate directive requested a cursor/connection
-          type_arg = extract_type_name
-          is_connection_type = type_arg && %w[CONNECTION CURSOR].include?(type_arg.to_s.upcase)
-
-          # Paginator object builder (responds to both `paginatorInfo` and `paginator_info`)
-          paginator_builder = proc do |pinfo, data|
-            paginator_info_object = OpenStruct.new(pinfo)
-            # Ensure both camelCase and underscored-methods can be resolved by fallback
-            if pinfo.is_a?(Hash)
-              underscored = {}
-              pinfo.each_key do |k|
-                key = k.to_s
-                snake = key.underscore
-                underscored[snake] = pinfo[k] unless pinfo.key?(snake)
-              end
-              underscored.each { |kk, vv| paginator_info_object[kk] = vv }
-            end
-
-            PaginatorResult.new(paginator_info: paginator_info_object, data: data)
-          end
-
-          # Define owner singleton method to support graphql-ruby's execution
-          resolver_instance = self
-          field_ast_node = @field_def.ast_node
-          target_type_class.define_singleton_method(method_name) do |obj, arguments, ctx|
-            model_class = model_lookup.call
-            return [] unless model_class
-
-            args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
-
-            limit = args_h[:first]
-            offset = 0
-            if args_h[:after]
-              begin
-                decoded = Base64.decode64(args_h[:after])
-                if decoded.start_with?('offset:')
-                  offset = decoded.split(':', 2)[1].to_i
-                end
-              rescue StandardError
-                offset = 0
-              end
-            end
+# @paginate — paginate a model query, as PHP Lighthouse does. On a nested
+# field it pages the parent's association of the same name.
+#
+#   users(name: String @like): [User!]! @paginate(defaultCount: 25)
+#
+# `type:` picks PAGINATOR (default), SIMPLE or CONNECTION (see
+# Directives::PaginationManipulator for the generated schema). The query is
+# the model's (`model:`, else the return type), narrowed by `scopes:`,
+# @builder and the field's argument filters (@eq, @where, @orderBy,
+# @whereConditions, ...). `maxCount` caps `first` (null: unlimited),
+# overriding Config.pagination_max_count.
+class Lighthouse::GraphQL::DirectiveResolvers::PaginateDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'paginate'
+
+  def self.definition
+    'directive @paginate(type: PaginateType = PAGINATOR, model: String, scopes: [String!], ' \
+      'defaultCount: Int, maxCount: Int) on FIELD_DEFINITION'
+  end
 
-            relation = model_class.all
+  def self.type_definitions
+    {
+      'PaginateType' => <<~GRAPHQL.chomp
+        "The type of pagination a field uses."
+        enum PaginateType {
+          "Offset-based pagination with page numbers and a total, like Laravel's LengthAwarePaginator."
+          PAGINATOR
+          "Offset-based pagination without a total count, which saves a query."
+          SIMPLE
+          "Cursor-based pagination, compatible with the Relay specification."
+          CONNECTION
+        }
+      GRAPHQL
+    }
+  end
 
-            relation = DirectiveResolvers::BuilderApplier.apply(relation, field_ast_node, args_h, ctx, resolver_instance)
+  def define_resolver(target_type_class)
+    me = self
+    install(target_type_class, lambda do |obj, args, ctx|
+      me.send(:resolve_page, obj, Lighthouse::Support::Arguments.shallow(args), ctx)
+    end)
+  end
 
-            relation = DirectiveResolvers::WhereConditionsApplier.apply(relation, args_h[:where] || args_h['where'])
-            relation = relation.offset(offset) if offset > 0
-            relation = relation.limit(limit) if limit
+  protected
 
-            if is_connection_type
-              ::GraphQL::Pagination::ArrayConnection.new(relation, context: ctx, parent: nil, field: nil, arguments: {})
-            else
-              data = relation.to_a
-              per_page = limit
-              total = relation.count
-              paginator_info = {
-                count: data.size,
-                currentPage: 1,
-                firstItem: data.any? ? (offset + 1) : nil,
-                hasMorePages: (offset + data.size) < total,
-                lastItem: data.any? ? (offset + data.size) : nil,
-                lastPage: per_page && per_page > 0 ? (total.to_f / per_page).ceil : 1,
-                perPage: per_page || data.size,
-                total: total
-              }
+  def resolve_page(obj, args, ctx)
+    Lighthouse::GraphQL::Pagination.paginate(page_list(obj, args, ctx), (directive_arg('type') || 'PAGINATOR').to_s.upcase, args, limits)
+  end
 
-              paginator_builder.call(paginator_info, data)
-            end
-          end
+  # On a nested field, the parent's association of that name (as in PHP
+  # Lighthouse, `User.posts @paginate` pages the user's posts), batched with
+  # the other parents' when the Dataloader can; otherwise, or with `model:`,
+  # the model's whole table.
+  def page_list(obj, args, ctx)
+    name = Lighthouse::Support::Naming.attribute(@field_def.name)
+    return decorate_relation(model_class.all, args, ctx) unless nested?(obj, name)
 
-          # Attach a field-level resolve_proc that delegates to the generated
-          # singleton resolver. This keeps runtime dispatch consistent with
-          # SchemaImplementation (which checks for resolve_field_* first).
-          if @field_def.respond_to?(:resolve_proc=)
-            @field_def.resolve_proc = ->(obj, arguments, ctx) do
-              target_type_class.public_send(method_name, obj, arguments, ctx)
-            end
-          end
-        end
+    dataloader = Lighthouse::Support::Batching.dataloader(ctx)
+    batch = dataloader && Lighthouse::GraphQL::RelationBatch.for(obj, name, args, self, ctx)
+    return Lighthouse::GraphQL::Pagination::BatchedList.new(batch, obj, dataloader) if batch
 
-        private
+    decorate_relation(obj.association(name.to_sym).scope, args, ctx)
+  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 nested?(obj, name)
+    !directive_arg('model') && obj.respond_to?(:association) && obj.class.reflect_on_association(name.to_sym)
+  end
 
+  public
 
-        def extract_type_name
-          arg = @directive_node.arguments&.find { |a| a.name == 'type' }
-          return nil unless arg
-          arg.value.respond_to?(:value) ? arg.value.value : arg.value
-        end
+  # `scopes:`, @builder and the argument filters, on one relation or a RelationBatch.
+  def decorate_relation(relation, args, ctx)
+    relation = Lighthouse::GraphQL::DirectiveResolvers::BuilderApplier.apply(apply_scopes(relation), @field_def.ast_node, args, ctx, self)
+    apply_where_filters(relation, args)
+  end
 
-        def extract_model_name_from_field_type
-          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
+  protected
 
-          # fallback for late-bound signatures like "InboxPaginator!"
-          @field_def.type.to_type_signature.to_s.gsub(/[!\[\]]/, '')
-        end
-      end
-    end
+  def limits
+    limits = { default_count: directive_arg('defaultCount') }
+    given = @directive_node.arguments.any? { |a| a.name == 'maxCount' }
+    limits[:max_count] = directive_arg('maxCount') || :unlimited if given
+    limits
   end
 end

data/lib/lighthouse/directive_resolvers/rename_resolver.rb

@@ -2,34 +2,28 @@
 
 require_relative 'base'
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # @rename(attribute: "snake_case_name") — explicit override of the default
-      # field reader. Reads the named attribute off the parent object regardless
-      # of the GraphQL field name.
-      class RenameDirectiveResolver < BaseDirectiveResolver
-        def self.directive_name = 'rename'
-        def self.definition = 'directive @rename(attribute: String!) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION'
+# @rename(attribute: "snake_case_name") — explicit override of the default
+# field reader. Reads the named attribute off the parent object regardless
+# of the GraphQL field name.
+class Lighthouse::GraphQL::DirectiveResolvers::RenameDirectiveResolver < Lighthouse::GraphQL::DirectiveResolvers::BaseDirectiveResolver
+  def self.directive_name = 'rename'
+  def self.definition = 'directive @rename(attribute: String!) on FIELD_DEFINITION | ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION'
 
-        def define_resolver(target_type_class)
-          method_name = "resolve_field_#{@field_def.name}"
-          attribute = Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'attribute').to_s
+  def define_resolver(target_type_class)
+    method_name = "resolve_field_#{@field_def.name}"
+    attribute = Lighthouse::Support::DirectiveArgs.literal(@directive_node, 'attribute').to_s
 
-          resolver = lambda do |obj, _arguments, _ctx|
-            next nil if obj.nil?
+    resolver = lambda do |obj, _arguments, _ctx|
+      next nil if obj.nil?
 
-            if obj.is_a?(Hash)
-              obj[attribute] || obj[attribute.to_sym]
-            elsif obj.respond_to?(attribute)
-              obj.public_send(attribute)
-            end
-          end
-
-          target_type_class.define_singleton_method(method_name, &resolver)
-          @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
-        end
+      if obj.is_a?(Hash)
+        obj[attribute] || obj[attribute.to_sym]
+      elsif obj.respond_to?(attribute)
+        obj.public_send(attribute)
       end
     end
+
+    target_type_class.define_singleton_method(method_name, &resolver)
+    @field_def.resolve_proc = resolver if @field_def.respond_to?(:resolve_proc=)
   end
 end

data/lib/lighthouse/directive_resolvers/resolution.rb

@@ -1,35 +1,39 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DirectiveResolvers
-      # Helper for "middleware" directives (@guard, @can) that need to wrap a
-      # field's existing resolver.
-      module Resolution
-        module_function
+# Helper for "middleware" directives (@guard, @can) that need to wrap a
+# field's existing resolver.
+module Lighthouse::GraphQL::DirectiveResolvers::Resolution
+  module_function
 
-        # Capture the field's current resolver (generated singleton method,
-        # resolve_proc, or the default attribute reader) as a callable
-        # (obj, args, ctx) -> value, so it can be wrapped. The returned callable
-        # is unaffected by subsequently redefining the singleton method.
-        def capture(target_type_class, method_name, field_def, field_name)
-          original_singleton = target_type_class.method(method_name) if target_type_class.respond_to?(method_name)
-          original_proc = field_def.resolve_proc if field_def.respond_to?(:resolve_proc) && field_def.resolve_proc
+  # Capture the field's current resolver (generated singleton method,
+  # resolve_proc, or the default attribute reader) as a callable
+  # (obj, args, ctx) -> value, so it can be wrapped. The returned callable
+  # is unaffected by subsequently redefining the singleton method.
+  def capture(target_type_class, method_name, field_def, field_name)
+    original_singleton = lighthouse_singleton(target_type_class, method_name)
+    original_proc = field_def.resolve_proc if field_def.respond_to?(:resolve_proc) && field_def.resolve_proc
 
-          lambda do |obj, arguments, ctx|
-            if original_singleton
-              original_singleton.call(obj, arguments, ctx)
-            elsif original_proc
-              original_proc.call(obj, arguments, ctx)
-            elsif obj.respond_to?(field_name)
-              obj.public_send(field_name)
-            else
-              snake = Lighthouse::Support::Naming.attribute(field_name)
-              obj.respond_to?(snake) ? obj.public_send(snake) : nil
-            end
-          end
-        end
+    lambda do |obj, arguments, ctx|
+      if original_singleton
+        original_singleton.call(obj, arguments, ctx)
+      elsif original_proc
+        original_proc.call(obj, arguments, ctx)
+      elsif obj.respond_to?(field_name)
+        obj.public_send(field_name)
+      else
+        snake = Lighthouse::Support::Naming.attribute(field_name)
+        obj.respond_to?(snake) ? obj.public_send(snake) : nil
       end
     end
   end
+
+  # graphql-ruby's SDL builder defines `resolve_field_*` methods of its own
+  # (with a different arity); only ours, defined under lib/lighthouse/, count.
+  def lighthouse_singleton(target_type_class, method_name)
+    return nil unless target_type_class.respond_to?(method_name)
+
+    method = target_type_class.method(method_name)
+    source_file, = method.source_location
+    method if source_file&.include?('/lib/lighthouse/')
+  end
 end