lighthouse-graphql 0.1.0

data/lib/lighthouse/directive_resolvers/belongs_to_many_resolver.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      class BelongsToManyDirectiveResolver < BaseDirectiveResolver
+        def define_resolver(target_type_class)
+          field_name = @field_def.name
+          assoc_name = extract_relation_name || field_name
+
+          method_name = "resolve_field_#{field_name}"
+
+          target_type_class.define_singleton_method(method_name) do |obj, arguments, ctx|
+            # Use dataloader when available
+            if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
+              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
+              return loader.load(obj)
+            end
+
+            # Fallback: call the association directly
+            if obj.respond_to?(assoc_name)
+              args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+              return obj.public_send(assoc_name)
+            end
+
+            nil
+          end
+
+          if @field_def.respond_to?(:resolve_proc=)
+            @field_def.resolve_proc = ->(obj, arguments, ctx) do
+              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
+                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
+                loader.load(obj)
+              elsif obj.respond_to?(assoc_name)
+                args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+                obj.public_send(assoc_name)
+              else
+                nil
+              end
+            end
+          end
+        end
+
+        private
+
+        def extract_relation_name
+          arg = @directive_node.arguments&.find { |a| a.name == 'relation' }
+          return nil unless arg
+          arg.value.respond_to?(:value) ? arg.value.value : arg.value
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/belongs_to_resolver.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      class BelongsToDirectiveResolver < BaseDirectiveResolver
+        def define_resolver(target_type_class)
+          field_name = @field_def.name
+          assoc_name = extract_relation_name || field_name
+          method_name = "resolve_field_#{field_name}"
+
+          target_type_class.define_singleton_method(method_name) do |obj, _arguments, ctx|
+            if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
+              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
+              return loader.load(obj)
+            end
+
+            obj.public_send(assoc_name) if obj.respond_to?(assoc_name)
+          end
+
+          if @field_def.respond_to?(:resolve_proc=)
+            @field_def.resolve_proc = ->(obj, _arguments, ctx) do
+              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
+                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
+                loader.load(obj)
+              elsif obj.respond_to?(assoc_name)
+                obj.public_send(assoc_name)
+              else
+                nil
+              end
+            end
+          end
+        end
+
+        private
+
+        def extract_relation_name
+          arg = @directive_node.arguments&.find { |a| a.name == 'relation' }
+          return nil unless arg
+          arg.value.respond_to?(:value) ? arg.value.value : arg.value
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/builder_applier.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/can_resolver.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      # @can — authorize access to a field using a policy ability (Pundit by
+      # default; configurable via Config.authorizer). Mirrors PHP Lighthouse's
+      # @can* family. Repeatable.
+      #
+      #   contact(id: ID!): Contact @field(resolver: "...") @can(ability: "show")
+      #
+      # Modes:
+      #   * default          — resolve the field, then authorize the resolved
+      #                        record (skips nil; passes collections through —
+      #                        use scoping for lists).
+      #   * root: true       — authorize the parent object before resolving.
+      #   * find / model     — look the model up by an argument and authorize it
+      #                        before resolving.
+      class CanDirectiveResolver < BaseDirectiveResolver
+        def self.directive_name = 'can'
+        def self.definition
+          'directive @can(ability: String!, find: String, model: String, root: Boolean) repeatable on FIELD_DEFINITION'
+        end
+
+        def define_resolver(target_type_class)
+          field_name = @field_def.name
+          method_name = "resolve_field_#{field_name}"
+          ability = directive_arg('ability')
+          return if ability.nil?
+
+          find_arg = directive_arg('find')
+          model_name = directive_arg('model')
+          root = directive_arg('root')
+          inner = Resolution.capture(target_type_class, method_name, @field_def, field_name)
+          resolver_instance = self
+
+          wrapper = lambda do |obj, arguments, ctx|
+            if root
+              resolver_instance.send(:authorize_or_raise, ctx, obj, ability)
+              next inner.call(obj, arguments, ctx)
+            end
+
+            if find_arg && model_name
+              args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+              id = Lighthouse::Support::Naming.fetch_arg(args_h, find_arg)
+              model_class = resolver_instance.send(:constantize_model, model_name)
+              record = model_class&.find_by(id: id)
+              resolver_instance.send(:authorize_or_raise, ctx, record, ability)
+              next inner.call(obj, arguments, ctx)
+            end
+
+            result = inner.call(obj, arguments, ctx)
+            resolver_instance.send(:authorize_resolved, ctx, result, ability)
+          end
+
+          target_type_class.define_singleton_method(method_name, &wrapper)
+          @field_def.resolve_proc = wrapper if @field_def.respond_to?(:resolve_proc=)
+        end
+
+        private
+
+        def directive_arg(name)
+          Lighthouse::Support::DirectiveArgs.literal(@directive_node, name)
+        end
+
+        def authorize_resolved(ctx, result, ability)
+          return result if result.nil?
+          # Collections are filtered with scoping, not item-by-item authorization.
+          return result if result.respond_to?(:each) && !result.respond_to?(:id)
+
+          authorize_or_raise(ctx, result, ability)
+          result
+        end
+
+        def authorize_or_raise(ctx, record, ability)
+          return if record.nil?
+
+          authorized = Lighthouse::Support::Authorization.authorized?(ctx, record, ability)
+          raise(::GraphQL::ExecutionError, 'You are not authorized to perform this action.') unless authorized
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/count_resolver.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/field_resolver.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+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
+
+        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 execute_resolver(resolver_class, obj, args, ctx)
+          return nil unless resolver_class
+
+          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
+  end
+end

data/lib/lighthouse/directive_resolvers/find_resolver.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+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
+
+            if id && ctx&.dataloader
+              loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::ModelLoader, model_class)
+              return loader.load(id)
+            end
+
+            model_class.find_by(id: id)
+          end
+
+          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']
+
+              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
+
+        private
+
+        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 constantize_model(name)
+          return nil unless name
+          name = name.to_s.split('::').last
+          Object.const_get(name) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/first_resolver.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/guard_resolver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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'
+
+        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)
+
+          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
+    end
+  end
+end

data/lib/lighthouse/directive_resolvers/has_many_resolver.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Lighthouse
+  module GraphQL
+    module DirectiveResolvers
+      class HasManyDirectiveResolver < BaseDirectiveResolver
+        def define_resolver(target_type_class)
+          field_name = @field_def.name
+          assoc_name = extract_relation_name || field_name
+          is_connection = @field_def.respond_to?(:connection?) ? @field_def.connection? : false
+
+          resolver_instance = self
+
+          # Keep compatibility with SchemaImplementation-based resolution by
+          # defining a singleton method on the owner type (e.g. Inbox.resolve_field_conversations).
+          method_name = "resolve_field_#{field_name}"
+
+          target_type_class.define_singleton_method(method_name) do |*args|
+            # Support both batch and single resolution modes.
+            # Batch mode signature: (objects_array, ctx)
+            # Single mode signature: (obj, arguments, ctx)
+            if args.length == 2 && args[0].is_a?(Array)
+              parents, ctx = args
+
+              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
+                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, parents.first.class, assoc_name)
+                parents.map do |p|
+                  promise = loader.load(p)
+                  if is_connection
+                    promise.then { |value| ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) }
+                  else
+                    promise
+                  end
+                end
+              else
+                parents.map do |p|
+                  value = p.respond_to?(assoc_name) ? p.public_send(assoc_name) : nil
+                  is_connection && value ? ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) : value
+                end
+              end
+            else
+              obj, arguments, ctx = args
+
+              # Use dataloader when available
+              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
+                args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
+                value = loader.load(obj)
+                if is_connection
+                  value.then do |v|
+                    filtered = resolver_instance.apply_where_filters(v, args_h)
+                    ::GraphQL::Pagination::ArrayConnection.new(filtered, context: ctx, parent: nil, field: nil, arguments: {})
+                  end
+                else
+                  value.then { |v| resolver_instance.apply_where_filters(v, args_h) }
+                end
+              elsif obj.respond_to?(assoc_name)
+                args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+                value = obj.public_send(assoc_name)
+                value = resolver_instance.apply_where_filters(value, args_h)
+                is_connection && value ? ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) : value
+              else
+                nil
+              end
+            end
+          end
+
+          # Also attach a resolve proc where supported by the GraphQL runtime.
+          if @field_def.respond_to?(:resolve_proc=)
+            @field_def.resolve_proc = ->(obj, arguments, ctx) do
+              if ctx && ctx.respond_to?(:dataloader) && ctx.dataloader
+                args_h = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+                loader = ctx.dataloader.with(Lighthouse::GraphQL::DataloaderSources::AssociationLoader, obj.class, assoc_name)
+                result = loader.load(obj)
+                if is_connection
+                  result.then do |value|
+                    filtered = resolver_instance.apply_where_filters(value, args_h)
+                    ::GraphQL::Pagination::ArrayConnection.new(filtered, context: ctx, parent: nil, field: nil, arguments: {})
+                  end
+                else
+                  result.then { |value| resolver_instance.apply_where_filters(value, args_h) }
+                end
+              elsif obj.respond_to?(assoc_name)
+                args = arguments.respond_to?(:to_h) ? arguments.to_h : {}
+                value = obj.public_send(assoc_name)
+                value = resolver_instance.apply_where_filters(value, args)
+                is_connection && value ? ::GraphQL::Pagination::ArrayConnection.new(value, context: ctx, parent: nil, field: nil, arguments: {}) : value
+              else
+                nil
+              end
+            end
+          end
+        end
+
+        private
+
+        def extract_relation_name
+          # directive syntax: @hasMany(relation: "name")
+          arg = @directive_node.arguments&.find { |a| a.name == 'relation' }
+          return nil unless arg
+          # value is AST literal node; use its value method if present
+          arg.value.respond_to?(:value) ? arg.value.value : arg.value
+        end
+      end
+    end
+  end
+end